# -*- coding: utf-8 -*-

 ###############################################
 ##                                             ##
 ##   Submódulo vista                            ##
 ##   @ Módulo ventas                            ##
 ##                                              ##
 ##   de la línea Básicos                        ##
 ##   de Críptidos Digitales                     ##
 ##   GPL (c)2008                                ##
  ##                                             ##
    ###############################################

# print (0), "  ventas.igu            begin"

import sys
from decimal import Decimal as dec, getcontext, ROUND_DOWN, ROUND_UP, ROUND_CEILING
from PyQt4 import QtCore, QtGui
import datetime
# getcontext().rounding = ROUND_UP
# print getcontext()
from cdWidgets import cdFrame, cdLineEdit, cdRfcEdit, cdNumberEdit

import frame_ui
import administradorVentas_ui as administrador_ui
import capturaVenta_ui as captura_ui
import detallesVenta_ui as detalles_ui
import pagos_ui

from personas import selector as selectorCliente


# import ventas as controller

# import ventas as manejador
import manejador
import utilities




VENTA_ID, FOLIO, FECHA, ENTIDAD, SUBTOTAL, DESCUENTOS, IMPUESTOS, TOTAL, STATUS = range(9)

CODIGO, NOMBRE, LINEA, CANTIDAD, PRECIO, IMPORTE = range(6)

controller = None


# print (0), "  ventas.igu              definitions"


class Forma(cdFrame.CDFrame):

    @property
    def app(self):
        return self.__app

    # @property
    # def controller(self):
        # return self.__controller

    @property
    def eventRouter(self):
        return self.__eventRouter

    @property
    def modo(self):
        return self.__modo

    @property
    def rangosPrecioActivos(self):
        return self.__rangosPrecioActivos


    def __init__(self, *args, **kwds):
        m = "ventas.igu.Forma.__init__()"

        if kwds.has_key('app'):
            self.__app = kwds.pop('app')
        else:
            self.__app = None

        if kwds.has_key('controller'):
            global controller
            controller = kwds.pop('controller')

        if 'eventRouter' in kwds.keys():
            self.__eventRouter = kwds.pop('eventRouter')
        else:
            self.__eventRouter = None

        if kwds.has_key('modo'):
            self.__modo = kwds.pop('modo')
        else:
            self.__modo = None

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        if 'eventRouter' in kwds.keys():
            self.__eventRouter = kwds.pop('eventRouter')
        else:
            self.__eventRouter = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = frame_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.frame1.close()
        self.ui.frame2.close()
        self.ui.frame3.close()

        ## Rangos de precio activos
        self.cargaRangosPrecioActivos()

        ## Detalles
        self.detalles = Detalles(self, owner=self)
        self.detalles.hide()

        ## Captura
        self.captura = Captura(self, owner=self)
        self.connect(self.captura, QtCore.SIGNAL("clientesChangedBroadcast()"), self.clientesChanged)
        self.connect(self.captura, QtCore.SIGNAL('capturaClosed()'), self.capturaClosed)
        self.connect(self.captura, QtCore.SIGNAL('lugaresChanged()'), self.lugaresChanged)

        ## Administrador
        self.administrador = Administrador(self, owner=self)

        self.ui.outerSplitter = Splitter(QtCore.Qt.Vertical, self)
        ## InnerSplitter
        self.ui.innerSplitter = Splitter(QtCore.Qt.Horizontal, self.ui.outerSplitter)
        self.ui.innerSplitter.insertWidget(0, self.administrador)
        self.ui.innerSplitter.insertWidget(1, self.detalles)
        self.connect(self.ui.innerSplitter.handle(1), QtCore.SIGNAL("handlePressed"), self.innerHandlePressed)
        self.ui.innerSplitter.setSizes([1, 1])

        ## OuterSplitter
        self.ui.outerSplitter.insertWidget(0, self.ui.innerSplitter)
        self.ui.outerSplitter.insertWidget(1, self.captura)
        self.connect(self.ui.outerSplitter.handle(1), QtCore.SIGNAL('handlePressed'), self.outerHandlePressed)
        self.ui.outerSplitter.setSizes([1, 1])
        self.ui.verticalLayout.addWidget(self.ui.outerSplitter)

        if self.modo == 'consulta':
            self.captura.ui.boCancelar.show()
            self.captura.hide()
            self.administrador.ui.toAgregar.hide()
            self.administrador.menuTablaConsulta.removeAction(self.administrador.aAgregar)
        elif self.modo == 'captura':
            self.administrador.hide()
            self.administrador.aEliminar.setEnabled(False)
            self.captura.ui.boCancelar.hide()
            self.captura.agrega()

        self.connect(controller.eventRouter, QtCore.SIGNAL('rangosPrecioChangedBroadcast()'), self.rangosPrecioChanged)

        self.impresor = QtGui.QPrinter()


    def capturaClosed(self):                # print "ventas.igu.Forma.capturaClosed()"
        self.setInnerStatus("visible")
        self.administrador.actualizaBotones()


    def cargaRangosPrecioActivos(self):
        rangosPrecio = manejador.rangosPrecio()
        self.__rangosPrecioActivos = []
        for index, rango in enumerate(rangosPrecio):
            if u'a' in rango.referencia:
                self.__rangosPrecioActivos.append(rango)


    def clientesChanged(self):              # print "ventas.igu.Forma.clientesChanged()"
        self.emit(QtCore.SIGNAL("clientesChanged()"))


    def imprime(self, documento=None):
        m = "ventas.igu.Forma.imprime()"

        dialogoImpresora = QtGui.QPrintDialog(self.impresor)
        if dialogoImpresora.exec_() == QtGui.QDialog.Accepted:

            painter = QtGui.QPainter(self.impresor)

            procesoServicioZero = [x for x in documento.operacion.procesos if x.tipo==u'servicio']
            if procesoServicioZero:
                servicio = [x.documento.servicio for x in procesoServicio[0].operaciones if x.tipo==u'recepción'][0]

            ## LISTA FILTRADA
            if documento is None:
                font = QtGui.QFont()
                font.setBold(True)
                font.setPointSize(10)
                font.setFamily('courier')

                painter.setFont(font)

                margenHorizontal, margenVertical = [10, 10]
                margenX, margenY = [25, 75]
                pageNo = 1
                contenido = []

                ## Header
                # Nombre de documento
                x,y = [ 20, 20]; contenido.append([margenX+x, margenY+y, u"Listado de Ventas"])
                # Fecha
                x,y = [528, 20]; contenido.append([margenX+x, margenY+y, u"%s" % datetime.datetime.today().strftime('%d de %B de %Y')])
                # Labels
                x,y = [ 25, 90]; contenido.append([margenX+x, margenY+y, u"Documento"])
                x,y = [140, 90]; contenido.append([margenX+x, margenY+y, u"Fecha"])
                x,y = [245, 90]; contenido.append([margenX+x, margenY+y, u"Monto"])
                x,y = [330, 90]; contenido.append([margenX+x, margenY+y, u"Status"])
                x,y = [435, 90]; contenido.append([margenX+x, margenY+y, u"Cliente"])

                x,y = [  0,120]
                offset = 0

                tabla = self.administrador.ui.tablaConsulta
                for rowIndex in range(tabla.rowCount()):
                    print tabla.item(rowIndex, 0).data(QtCore.Qt.UserRole).toInt()[0]
                    proceso = manejador.dameProceso(id=tabla.item(rowIndex, 0).data(QtCore.Qt.UserRole).toInt()[0])
                    documentoX = ([xx for xx in proceso.operaciones if xx.tipo==u'salida'][0]).documentos[0]
                    contenido.append([margenX+x+ 20, margenY+y+offset, "%s %s" % (documentoX.tipo.nombre.capitalize(), documentoX.folio)])
                    contenido.append([margenX+x+135, margenY+y+offset, documentoX.fecha.strftime("%d-%b-%Y")])
                    contenido.append([margenX+x+250, margenY+y+offset, "%s" % documentoX.total])
                    contenido.append([margenX+x+330, margenY+y+offset, documentoX.status])
                    contenido.append([margenX+x+420, margenY+y+offset, "%s %s" % (documentoX.rol.entidad.nombre, documentoX.rol.entidad.nombre2)])
                    offset += 25

                for item in contenido:
                    painter.drawText(QtCore.QPoint(item[0], item[1]), item[2])

            ## Documento 1 (Factura)
            elif documento.tipo.nombre == u'factura':

                font = QtGui.QFont()
                font.setBold(True)
                font.setPointSize(10)
                font.setFamily('courier')

                painter.setFont(font)

                margenX, margenY = [35, 85]

                pageNo = 1

                format = file("propio/factura.txt").read()
                formatList = format.replace("\n\n", "\n").split("\n")
                format = [(x.split(",")) for x in formatList]

                format = dict([(x[0], [int(y) for y in x[1:] if y]) for x in format if x[0][0]!="#"])

                # Folio
                painter.drawText(QtCore.QPoint(margenX+format['folio'][0], margenY+format['folio'][1]), documento.folio)

                # Fecha
                painter.drawText(QtCore.QPoint(margenX+format['fecha'][0], margenY+format['fecha'][1]), documento.fecha.strftime('%d de %B de %Y'))

                # Nombre
                painter.drawText(QtCore.QPoint(margenX+format['nombre'][0], margenY+format['nombre'][1]), u"%s %s" % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2))

                # Calle y colonia
                painter.drawText(QtCore.QPoint(margenX+format['direccion'][0], margenY+format['direccion'][1]), u"%s %s" % (documento.rol.direcciones[0].calle, documento.rol.direcciones[0].areanominal))

                # CP y Lugar
                painter.drawText(QtCore.QPoint(margenX+format['lugar'][0], margenY+format['lugar'][1]), u"CP %s   %s" % (documento.rol.direcciones[0].areapostal, documento.rol.direcciones[0].lugar.nombre))

                # RFC
                painter.drawText(QtCore.QPoint(margenX+format['rfc'][0], margenY+format['rfc'][1]), documento.rol.entidad.rfc)

                if procesoServicioZero:
                    # Código
                    painter.drawText(QtCore.QPoint(margenX+format['economico'][0], margenY+format['economico'][1]), servicio.equipo.codigo)

                    # Marca
                    painter.drawText(QtCore.QPoint(margenX+format['marca'][0], margenY+format['marca'][1]), "%s %s" % (servicio.equipo.marca.nombre, servicio.equipo.linea.nombre))

                    painter.drawText(QtCore.QPoint(margenX+formet['serie'][0], margenY+format['serie'][1]), "Serie %s" % servicio.equipo.serie)

                    # Modelo
                    painter.drawText(QtCore.QPoint(margenX+format['modelo'][0], margenY+format['modelo'][1]), servicio.equipo.modelo.nombre)

                    # Registro
                    painter.drawText(QtCore.QPoint(margenX+format['placa'][0], margenY+format['placa'][1]), servicio.equipo.registro)

                    # Nivel 2
                    painter.drawText(QtCore.QPoint(margenX+format['odometro'][0], margenY+format['odometro'][1]), servicio.nivel2)

                x, y = format['partidas']
                offset = 0

                for partida in documento.partidas:
                    acepcion = manejador.dameAcepcion(producto_id=partida.producto_id, rol_id=controller.app.holder.id)
                    painter.drawText(QtCore.QPoint(margenX+format['cantidad'][0], margenY+y+offset), "%s" % partida.cantidad)
                    painter.drawText(QtCore.QPoint(margenX+format['codigo'][0], margenY+y+offset), acepcion.codigo)
                    painter.drawText(QtCore.QPoint(margenX+format['descripcion'][0], margenY+y+offset), acepcion.nombre)
                    painter.drawText(QtCore.QPoint(margenX+format['linea'][0], margenY+y+offset), acepcion.producto.lineas[0].nombre)
                    painter.drawText(QtCore.QPoint(margenX+format['importe'][0], margenY+y+offset), "%8.2f" % (partida.cantidad * partida.precio))
                    offset += 20

                # Cantidad con letra
                painter.drawText(QtCore.QPoint(margenX+format['cantidadconletra'][0], margenY+format['cantidadconletra'][1]), "(%s M.N.)" % utilities.moneyToText(documento.total.quantize(dec('0.01'))))

                # Subtotal
                painter.drawText(QtCore.QPoint(margenX+format['subtotal'][0], margenY+format['subtotal'][1]), "%8.2f" % documento.subtotal)
                painter.drawText(QtCore.QPoint(margenX+format['impuesto'][0], margenY+format['impuesto'][1]), "%8.2f" % documento.impuesto)
                painter.drawText(QtCore.QPoint(margenX+format['total'][0], margenY+format['total'][1]), "%8.2f" % documento.total)

                # Pagaré
                if len(format['pagare.total']) == 4:
                    font.setPointSize(10)
                    painter.setFont(font)
                painter.drawText(QtCore.QPoint(margenX+format['pagare.total'][0], margenY+format['pagare.total'][1]), "%8.2f" % documento.total)
                painter.drawText(QtCore.QPoint(margenX+format['pagare.total'][0], margenY+format['pagare.total'][1]), "(%s M.N.)" % utilities.moneyToText(documento.total.quantize(dec('0.01'))))
                painter.drawText(QtCore.QPoint(margenX+format['pagare.fecha'][0], margenY+format['pagare.fecha'][1]), documento.fecha.strftime('%d de %B de %Y'))
                painter.drawText(QtCore.QPoint(margenX+format['pagare.interes'][0], margenY+format['pagare.interes'][1]), "10")
                painter.drawText(QtCore.QPoint(margenX+format['pagare.nombre'][0], margenY+format['pagare.nombre'][1]), u"%s %s" % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2))
                painter.drawText(QtCore.QPoint(margenX+format['pagare.direccion'][0], margenY+format['pagare.direccion'][1]), u"%s %s %s %s" % (documento.rol.direcciones[0].calle, documento.rol.direcciones[0].areanominal, documento.rol.direcciones[0].areapostal, documento.rol.direcciones[0].lugar.nombre))
                painter.drawText(QtCore.QPoint(margenX+format['pagare.fecha'][0], margenY+format['pagare.fecha'][1]), documento.fecha.strftime('%d de %B de %Y'))


            ## DOCUMENTO 2 (REMISIÓN)
            elif documento.tipo.nombre == u'remisión':

                font = QtGui.QFont()
                font.setBold(True)
                font.setPointSize(10)
                font.setFamily('courier')

                painter.setFont(font)

                margenX, margenY = [35, 35]
                pageNo = 1

                formatList = file("propio/remision.txt").read()
                formatList = formatList.replace("\n\n", "\n").replace("\n\n", "\n").replace("\n\n", "\n").split("\n")
                format = {}
                for item in formatList:
                    if item and item != ' ':
                        items = item.split(" , ")
                        if items[0][0] != "#":
                            items[1] = int(items[1])
                            items[2] = int(items[2])
                            format[items[0]] = items[1:]

                # Logo
                painter.drawPixmap(QtCore.QPoint(margenX, margenY), QtGui.QPixmap("propio/logo.jpg"))

                # Folio
                painter.drawText(QtCore.QPoint(margenX+format['folio'][0]+30, margenY+format['folio'][1]-25), u"REMISIÓN")
                painter.drawText(QtCore.QPoint(margenX+format['folio'][0]+40, margenY+format['folio'][1]), documento.folio)

                # Fecha
                painter.drawText(QtCore.QPoint(margenX+format['fecha'][0]+40, margenY+format['fecha'][1]-25), u"FECHA")
                painter.drawText(QtCore.QPoint(margenX+format['fecha'][0], margenY+format['fecha'][1]), documento.fecha.strftime('%d de %B de %Y'))

                # Cliente Nombre
                painter.drawText(QtCore.QRectF(margenX+format['cliente.nombre'][0]-125, margenY+format['cliente.nombre'][1], 100, 30), u"Cliente", QtGui.QTextOption(QtCore.Qt.AlignRight))

                painter.drawText(QtCore.QRectF(margenX+format['cliente.nombre'][0],  margenY+format['cliente.nombre'][1], margenX+format['cliente.nombre'][0]+400, margenY+format['cliente.nombre'][1]), u"%s %s" % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2))

                if procesoServicioZero:
                    # Vehiculo
                    painter.drawText(QtCore.QRectF(margenX+format['vehiculo.descripcion'][0]-100, margenY+format['vehiculo.descripcion'][1], margenX+format['vehiculo.descripcion'][0], margenY+format['vehiculo.descripcion'][1]-10, margenY+format['vehiculo.descripcion'][1]+20), u"Vehículo", QtGui.QTextOption(QtCore.Qt.AlignRight))

                    painter.drawText(QtCore.QPoint(margenX+format['vehiculo.descripcion'][0], margenY+format['vehiculo.descripcion'][1]), "%s %s %s %s %s" % (servicio.equipo.codigo, servicio.equipo.marca.nombre, servicio.equipo.linea.nombre, servicio.equipo.modelo.nombre, servicio.equipo.registro))

                # Partidas
                x, y = format['partidas']
                offset = 0

                painter.drawText(QtCore.QPoint(margenX+10, margenY+y-35), u"CANTIDAD")
                painter.drawText(QtCore.QPoint(margenX+190, margenY+y-35), u"CONCEPTO")
                painter.drawText(QtCore.QPoint(margenX+610, margenY+y-35), u"IMPORTE")

                for partida in documento.partidas:
                    acepcion = manejador.dameAcepcion(producto_id=partida.producto_id, rol_id=controller.app.holder.id)
                    painter.drawText(QtCore.QPoint(margenX+format['cantidad'][0], margenY+y+offset), "%s" % partida.cantidad)
                    painter.drawText(QtCore.QPoint(margenX+format['descripcion'][0], margenY+y+offset), acepcion.codigo)
                    painter.drawText(QtCore.QPoint(margenX+format['descripcion'][0]+90, margenY+y+offset), acepcion.nombre)
                    painter.drawText(QtCore.QPoint(margenX+format['descripcion'][0]+290, margenY+y+offset), acepcion.producto.clasificacion.nombre)
                    painter.drawText(QtCore.QRectF(margenX+format['importe'][0], margenY+y+offset-10, 115, 20), "%8.2f" % (partida.cantidad * partida.precio), QtGui.QTextOption(QtCore.Qt.AlignRight))
                    offset += 20

                # Cantidad con letras
                painter.drawText(QtCore.QPoint(margenX+format['cantidadconletra'][0], margenY+format['cantidadconletra'][1]), "(%s M.N.)" % utilities.moneyToText(documento.total.quantize(dec('0.01'))))

                # Total
                painter.drawText(QtCore.QRectF(margenX+format['total'][0]-100, margenY+format['total'][1]+5, 100, 20), u"Total", QtGui.QTextOption(QtCore.Qt.AlignRight))

                painter.drawText(QtCore.QRectF(margenX+format['total'][0], margenY+format['total'][1]+5, 115, 20), "%8.2f" % documento.subtotal, QtGui.QTextOption(QtCore.Qt.AlignRight))

                # PAGARÉ
                painter.drawText(QtCore.QRectF(margenX+format['pagare.texto'][0]+10, margenY+format['pagare.texto'][1]+10, margenX+format['pagare.texto'][0]+660, margenY+format['pagare.texto'][1]+180), (format['pagare.texto'][2] % (u"%8.2f" % documento.subtotal, documento.fecha.strftime('%d de %B de %Y'), unicode("%s %s", "latin1") % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2), u"", documento.fecha.strftime('%d de %B de %Y'))).replace(u'[LF]', u'\n'))


                pen = painter.pen()
                pen.setWidth(2)
                painter.setPen(pen)

                # MARCO FOLIO
                painter.drawRect(QtCore.QRect(margenX+format['folio'][0]-20, margenY+format['folio'][1]-40, 175, 20))
                painter.drawRect(QtCore.QRect(margenX+format['folio'][0]-20, margenY+format['folio'][1]-20, 175, 30))

                # Marco Fecha
                painter.drawRect(QtCore.QRect(margenX+format['fecha'][0]-20, margenY+format['fecha'][1]-40, 175, 20))
                painter.drawRect(QtCore.QRect(margenX+format['fecha'][0]-20, margenY+format['fecha'][1]-20, 175, 30))

                # Marco Labels
                painter.drawRect(QtCore.QRect(margenX, margenY+y-50, 700, 25))  # Labels

                # Marco Total
                painter.drawRect(QtCore.QRect(margenX+format['total'][0]+25, margenY+format['total'][1], 100, 30))

                # Marco pagaré
                painter.drawRect(QtCore.QRect(margenX+format['pagare.texto'][0], margenY+format['pagare.texto'][1], 700, 200))

                for marco in [format[x] for x in format.keys() if 'marco' in x]:
                    painter.drawRect(margenX+marco[0], margenY+marco[1], int(marco[2]), int(marco[3]))


    def innerHandlePressed(self):           # print "ventas.igu.Forma.innerHandlePressed()"
        self.toggleDetalles()

    def lugaresChanged(self):               # print "ventas.igu.Forma.lugaresChanged()"
        self.emit(QtCore.SIGNAL('lugaresChanged()'))

    def outerHandlePressed(self):           # print "ventas.igu.Forma.outerHandlePressed()"
        if self.modo == 'consulta':
            if self.ui.outerSplitter.sizes()[0] == 0:
                self.setInnerStatus('visible')
            else:
                self.setInnerStatus('hidden')


    @property
    def owner(self):
        return self.__owner


    def rangosPrecioChanged(self):
        self.cargaRangosPrecioActivos()
        #! Falta actualizar vistas involucradas


    def setInnerStatus(self, value):        # print "ventas.igu.Forma.setInnerStatus(%s)" % value
        if value == 'visible':
            self.administrador.show()
            if self.detalles.status == 'hidden':
                self.detalles.show()
                self.detalles.status = "normal"
        elif value == 'hidden':
            self.administrador.hide()
            if self.detalles.isVisible():
                self.detalles.status = "hidden"
                self.detalles.hide()
        elif value == 'disabled':
            print 'disables'


    def toggleDetalles(self, *args):        # print "ventas.igu.Forma.toggleDetalles()"
        if self.detalles.isVisible():
            self.detalles.hide()
        else:
            self.detalles.show()
            if self.administrador.ui.tablaConsulta.currentRow() != -1:
                id = self.administrador.ui.tablaConsulta.item(self.administrador.ui.tablaConsulta.currentRow(), 0).data(QtCore.Qt.UserRole).toInt()[0]
                proceso = manejador.dameProceso(id=id)
                self.detalles.setData(proceso)



class Administrador(cdFrame.CDFrame):

    @property
    def app(self):
        return self.__owner.app

    @property
    def owner(self):
        return self.__owner

    def __init__(self, *args, **kwds):
        m = "ventas.igu.Administrador.__init__()"
        # print (1), m

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = administrador_ui.Ui_Form()
        self.ui.setupUi(self)

        ## FILTROS
        self.ui.laFiltroCliente.setStyleSheet("QLabel:enabled{background-color:#0000FF; color:#FFFFFF;}")

        ## Filtros - Nombre de cliente
        completer = QtGui.QCompleter([], self.ui.edNombreCliente)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.ui.edNombreCliente.setCompleter(completer)
        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.nombreClienteSeleccionado)
        self.connect(self.ui.edNombreCliente, QtCore.SIGNAL("textEdited(QString)"), self.nombreClienteEditado)

        ## Filtros - Rango de fechas
        self.ui.laFiltroFechas.setStyleSheet("QLabel:enabled{background-color:#0000FF; color:#FFFFFF;}")
        self.ui.fecha1.setDisplayFormat("dd MMM yyyy")
        self.ui.fecha1.setDate(QtCore.QDate().currentDate().addDays(-7))
        self.connect(self.ui.fecha1, QtCore.SIGNAL("dateChanged(QDate)"), self.fechaChanged)

        self.ui.fecha2.setDisplayFormat("dd MMM yyyy")
        self.ui.fecha2.setDate(QtCore.QDate().currentDate())
        self.connect(self.ui.fecha2, QtCore.SIGNAL("dateChanged(QDate)"), self.fechaChanged)

        self.ui.laFiltroVarios.setStyleSheet("QLabel:enabled{background-color:#0000FF; color:#FFFFFF;}")

        ## Filtros - Incluir servicios
        if controller.app.formacion == controller.app.BASICO:
            self.ui.frame.hide()
            self.connect(self.ui.chIncluirServicios, QtCore.SIGNAL("stateChanged()"), self.incluirServiciosChanged)

        ## Filtros - SumasDiarias
        self.connect(self.ui.chSumasDiarias, QtCore.SIGNAL("stateChanged(int)"), self.sumasDiariasChanged)

        ## TABLA DE CONSULTA
        # self.ui.tablaConsulta.setStyleSheet("background-color:#FFFFFF")
        self.ui.tablaConsulta.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        self.ui.tablaConsulta.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        self.ui.tablaConsulta.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.ui.tablaConsulta.setColumnCount(6)
        self.ui.tablaConsulta.setHorizontalHeaderLabels([u"Folio", u"Documento", u"Fecha", u"Status", u"Monto", u"Cliente"])
        self.ui.tablaConsulta.horizontalHeader().setResizeMode(4, QtGui.QHeaderView.Stretch)

        self.ui.tablaConsulta.sortItems(-1)

        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemDoubleClicked(QTableWidgetItem *)"), self.owner.toggleDetalles)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemSelectionChanged()"), self.selectionChanged)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.mostrarMenuConsulta)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("resized(QEvent)"), self.resizedTablaConsulta)

        ## Agregar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Plus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aAgregar = QtGui.QAction(icon, u"&Agregar", self)
        self.aAgregar.setCheckable(True)
        self.aAgregar.setIconText(u"&Agregar")
        self.connect(self.aAgregar, QtCore.SIGNAL("triggered()"), self.agrega)

        self.ui.toAgregar.setDefaultAction(self.aAgregar)
        self.ui.toAgregar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toAgregar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Modificar
        icon1 = QtGui.QIcon()
        icon1.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aModificar = QtGui.QAction(icon1, u"&Modificar", self)
        self.aModificar.setCheckable(True)
        self.aModificar.setIconText(u"&Modificar")
        self.connect(self.aModificar, QtCore.SIGNAL("triggered()"), self.modifica)

        self.ui.toModificar.setDefaultAction(self.aModificar)
        self.ui.toModificar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toModificar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Eliminar
        icon2 = QtGui.QIcon()
        icon2.addPixmap(QtGui.QPixmap("imagenes/Minus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aEliminar = QtGui.QAction(icon2, u"&Eliminar", self)
        self.aEliminar.setCheckable(True)
        self.aEliminar.setIconText(u"&Eliminar")
        self.ui.toEliminar.setDefaultAction(self.aEliminar)
        self.ui.toEliminar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toEliminar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
        self.connect(self.aEliminar, QtCore.SIGNAL("triggered()"), self.elimina)

        # if not self.owner.app.reach&3:
            # self.ui.toEliminar.setVisible(False)
            # self.aEliminar.setVisible(False)
            # self.aEliminar.setToolTip(u"El borrado de ventas no está permitido")

        ## Detalles
        self.aDetalles = QtGui.QAction(u"Detalles", self)
        self.aDetalles.setShortcut(QtGui.QKeySequence(QtCore.Qt.ALT + QtCore.Qt.Key_D))
        self.connect(self.aDetalles, QtCore.SIGNAL("triggered()"), self.detallesTriggered)

        ## Imprimir
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aImprimir = QtGui.QAction(icon, u"Imprimir", self)
        self.aImprimir.setIconText(u"&Imprimir")
        self.connect(self.aImprimir, QtCore.SIGNAL("triggered()"), self.owner.imprime)

        self.ui.toImprimir.setDefaultAction(self.aImprimir)
        self.ui.toImprimir.setIconSize(QtCore.QSize(44, 40))
        self.ui.toImprimir.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
        self.ui.toImprimir.setToolTip(u"Se imprime sólo los renglones mostrados en la lista")

        ## Menu
        self.menuTablaConsulta = QtGui.QMenu(self)
        self.menuTablaConsulta.addAction(self.aAgregar)
        self.menuTablaConsulta.addAction(self.aModificar)
        self.menuTablaConsulta.addAction(self.aEliminar)

        # self.connect(self.parent(), QtCore.SIGNAL("ventasChanged()"), self.actualizaConsulta)
        self.connect(controller.eventRouter, QtCore.SIGNAL("clientesChangedBroadcast()"), self.actualizaConsulta)

        self.connect(controller.eventRouter, QtCore.SIGNAL("ventasChangedBroadcast()"), self.actualizaConsulta)

        ## Last Settings
        self.cliente = None
        self.actualizaConsulta()

        self.connect(self, QtCore.SIGNAL('showed()'), self.showed)


    def incluirServiciosChanged(self):
        self.actualizaConsulta()


    def actualizaBotones(self):             # print "ventas.igu.Administrador.actualizaBotones()"
        if not self.owner.captura.isVisible():
            self.aModificar.setChecked(False)
        self.aImprimir.setChecked(False)

        mensajesFiltros = u""
        mensajesModifica = u""
        mensajesImprime = u""

        if manejador.totalDeVentas() == 0:
            mensajesFiltros += u"No hay ventas registradas\n"
            mensajesModifica += u"No hay ventas registradas\n"
            mensajesImprime += u"No hay ventas para imprimir\n"
        elif self.ui.tablaConsulta.rowCount() == 0:
            mensajesModifica += u"No hay ventas desplegadas\n"
            mensajesImprime += u"No hay compras desplegadas\n"
        elif self.ui.tablaConsulta.rowCount() > 0:
            if self.ui.tablaConsulta.currentRow() == -1:
                mensajesModifica += u"Selecciona la Compra que quieres Modificar"

        if mensajesFiltros:
            self.ui.frFiltros.setEnabled(False)
            self.ui.frFiltros.setToolTip(mensajesFiltros.rstrip("\n"))
        else:
            self.ui.frFiltros.setEnabled(True)
            self.ui.frFiltros.setToolTip(u"")

        if mensajesModifica:
            self.aModificar.setEnabled(False)
            self.aModificar.setToolTip(mensajesModifica.rstrip("\n"))
        else:
            self.aModificar.setEnabled(True)
            self.aModificar.setToolTip(u"Presiona para modificar los datos de la Venta seleccionada")

        if mensajesImprime:
            self.aImprimir.setEnabled(False)
            self.aImprimir.setToolTip(mensajesImprime.rstrip("\n"))
        else:
            self.aImprimir.setEnabled(True)
            self.aImprimir.setToolTip(u"Presiona para Imprimir las ventas mostradas")


    def actualizaConsulta(self, date=None):
        m = "ventas.igu.Administrador.actualizaConsulta()"
        # print (1), m

        filtros = {}
        filtros['inicio'] = self.ui.fecha1.date().toPyDate()
        filtros['termino'] = self.ui.fecha2.date().toPyDate() + datetime.timedelta(days=1)
        # filtros['termino'] = datetime.datetime.combine(self.ui.fecha2.date().toPyDate(), datetime.time(23, 59, 59, 9999))
        # filtros['fecha1'] = self.ui.fecha1.date().toPyDate()
        # filtros['fecha2'] = self.ui.fecha2.date().toPyDate()

        if self.cliente:
            filtros['cliente_id'] = self.cliente.id

        self.ui.tablaConsulta.setRowCount(0)

        if self.ui.chSumasDiarias.isChecked():
            self.ui.tablaConsulta.setColumnCount(5)
            self.ui.tablaConsulta.setHorizontalHeaderLabels([u"Fecha", "Monto s/IVA", "Monto c/IVA", u"", u""])
            filtros['sumasDiarias'] = True

            datos = manejador.dameProcesos(**filtros)

            self.ui.tablaConsulta.setRowCount(len(datos))

            semana = dec("0.00")
            total = dec("0.00")

            for index, dato in enumerate(datos):
                item = QtGui.QTableWidgetItem(dato['fecha'].toString("dd MMM yyyy"))
                # item.setFont(font)
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setData(QtCore.Qt.UserRole, QtCore.QVariant(datos['id']))
                self.ui.tablaConsulta.setItem(index, 0, item)

                item1 = QtGui.QTableWidgetItem(str(dato['total']))
                item1.setFlags(item1.flags().__xor__(QtCore.Qt.ItemIsEditable))
                self.ui.tablaConsulta.setItem(index, 1, item1)

                item2 = QtGui.QTableWidgetItem(str(dato['total']))
                item2.setFlags(item2.flags().__xor__(QtCore.Qt.ItemIsEditable))
                self.ui.tablaConsulta.setItem(index, 2, item2)

                semana += dato['total']
                total += dato['total']

                if dato['fecha'].dayOfWeek() == 6:
                    item3 = QtGui.QTableWidgetItem(str(semana))
                    item4 = QtGui.QTableWidgetItem(str(total))
                else:
                    item3 = QtGui.QTableWidgetItem("")
                    item4 = QtGui.QTableWidgetItem("")
                item3.setFlags(item3.flags().__xor__(QtCore.Qt.ItemIsEditable))
                self.ui.tablaConsulta.setItem(index, 3, item3)

                item4.setFlags(item4.flags().__xor__(QtCore.Qt.ItemIsEditable))
                self.ui.tablaConsulta.setItem(index, 4, item4)

                if dato['fecha'].dayOfWeek() == 7:
                    semana = dec("0.00")
                    item.setBackgroundColor(QtGui.QColor(255,102,102))
                    item1.setBackgroundColor(QtGui.QColor(255,102,102))
                    item2.setBackgroundColor(QtGui.QColor(255,102,102))
                    item3.setBackgroundColor(QtGui.QColor(255,102,102))
                    item4.setBackgroundColor(QtGui.QColor(255,102,102))

        else:
            labels = [u"Id", u"Documento", u"Folio", u"Fecha", u"Cliente", u"Monto", u"Saldo", u"Status"]
            self.ui.tablaConsulta.setColumnCount(len(labels))
            self.ui.tablaConsulta.setHorizontalHeaderLabels(labels)
            self.ui.tablaConsulta.hideColumn(0)

            self.ui.tablaConsulta.horizontalHeader().setResizeMode(4, QtGui.QHeaderView.Stretch)

            procesos = manejador.dameProcesos(**filtros)

            self.ui.tablaConsulta.setSortingEnabled(False)

            self.ui.tablaConsulta.setRowCount(0)
            color = QtGui.QColor(1,1,1)
            saldo = dec('0.00')
            documentosProcesados = []

            for indexProceso, proceso in enumerate(procesos):
                if indexProceso%2:
                    color.setNamedColor('#E0E0FF')
                else:
                    color.setNamedColor('#FFFFE0')

                subProcesos = []

                operaciones = [x for x in proceso.operaciones if x.tipo==u'salida']

                for indexOperacion, operacion in enumerate(operaciones):

                    if operacion.documentos:
                        documento = operacion.documentos[0]
                        if documento.id == -1:
                            subProcesos.append([proceso.id, operacion.tipo, u'', operacion.fecha, u'', operacion.monto, operacion.status])
                        else:
                            if not documento.id in documentosProcesados:
                                subProcesos.append([proceso.id, documento.tipo.nombre, documento.folio, documento.fecha, "%s %s" % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2), documento.total, documento.status])
                                documentosProcesados.append(documento.id)
                    else:
                        if operacion.tipo != u'Cobro':
                            print (55555), 'ERROR ------------------------'
                            print "ventas.igu.Administrador.actualizaConsulta()"
                            print "proceso:", indexProceso, proceso
                            print "operacion:", indexOperacion, operacion
                            print "documentos:", operacion.documentos

                for indexSubproceso in range(len(subProcesos)-1):
                    for indexSubproceso2 in range(len(subProcesos)-1-indexSubproceso):
                        if subProcesos[indexSubproceso2][3] > subProcesos[indexSubproceso2+1][3]:
                            temp = subProcesos[indexSubproceso2]
                            subProcesos[indexSubproceso2] = subProcesos[indexSubproceso2+1]
                            subProcesos[indexSubproceso2+1] = temp

                for indexSubproceso, subProceso in enumerate(subProcesos):

                    self.ui.tablaConsulta.insertRow(0)

                    if subProceso[1] in [u'factura', u'remisión']:
                        saldo -= abs(subProceso[5])
                    elif not subProceso[1] in [u'pedido']:
                        saldo += abs(subProceso[5])

                    item = QtGui.QTableWidgetItem("")
                    item.setData(QtCore.Qt.UserRole, QtCore.QVariant(subProceso[0]))
                    self.ui.tablaConsulta.setItem(0, 0, item)

                    item = QtGui.QTableWidgetItem(subProceso[1].capitalize())
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    # if not index2:
                        # item.setTextAlignment(QtCore.Qt.AlignLeft)
                    # else:
                        # item.setTextAlignment(QtCore.Qt.AlignRight)
                    item.setBackgroundColor(color)
                    self.ui.tablaConsulta.setItem(0, 1, item)

                    item = QtGui.QTableWidgetItem("%s" % subProceso[2])
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    item.setTextAlignment(QtCore.Qt.AlignCenter)
                    item.setBackgroundColor(color)
                    self.ui.tablaConsulta.setItem(0, 2, item)

                    item = QtGui.QTableWidgetItem(subProceso[3].strftime("%d %b %Y"))
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    item.setTextAlignment(QtCore.Qt.AlignCenter)
                    item.setBackgroundColor(color)
                    self.ui.tablaConsulta.setItem(0, 3, item)

                    item = QtGui.QTableWidgetItem(subProceso[4])
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    item.setBackgroundColor(color)
                    self.ui.tablaConsulta.setItem(0, 4, item)

                    item = QtGui.QTableWidgetItem("%.2f" % subProceso[5])
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    item.setTextAlignment(QtCore.Qt.AlignCenter)
                    item.setBackgroundColor(color)
                    self.ui.tablaConsulta.setItem(0, 5, item)

                    item = QtGui.QTableWidgetItem("%.2f" % saldo)
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    item.setTextAlignment(QtCore.Qt.AlignCenter)
                    item.setBackgroundColor(color)
                    self.ui.tablaConsulta.setItem(0, 6, item)

                    item = QtGui.QTableWidgetItem(subProceso[6])
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    item.setTextAlignment(QtCore.Qt.AlignCenter)
                    item.setBackgroundColor(color)
                    self.ui.tablaConsulta.setItem(0, 7, item)

            self.ui.tablaConsulta.setSortingEnabled(True)

            self.actualizaBotones()

            self.ui.tablaConsulta.resizeColumnToContents(1)
            self.ui.tablaConsulta.resizeColumnToContents(2)
            # self.ui.tablaConsulta.resizeColumnToContents(3)
            self.ui.tablaConsulta.resizeColumnToContents(7)



    def setCurrentId(self, id):
        self.ui.tablaConsulta.setCurrentItem(self.ui.tablaConsulta.item(self.findData(id), 0))



    def agrega(self):
        self.owner.captura.agrega()


    def clienteSeleccionado(self, cliente): # print "ventas.igu.Administrador.clienteSeleccionado(%s)" % acepcion

        self.ui.edNombreCliente.setText("%s %s" % (cliente.entidad.nombre, cliente.entidad.nombre2))
        self.ui.edRFCCliente.setText(cliente.entidad.rfc)

        self.cliente = cliente

        self.actualizaConsulta()


    # def currentChanged(self, new, old):       # print "ventas.igu.Administrador.currentChanged()"
        # if new and not old:
            # self.toggleDetalles()


    def detallesTriggered(self):
        if self.ui.tablaConsulta.selectedItems():
            self.mostrarDetalles()
        else:
            self.owner.app.beep()


    def elimina(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar venta", u"Selecciona la Venta que quieres ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            dato = manejador.documento(id=id)
            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar venta", u"¿Realmente quieres ELIMINAR la Venta %s %s?" % (dato.folio, dato.fecha), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
            if result == QtGui.QMessageBox.Yes:
                manejador.elimina(id=id)
                self.actualizaConsulta()
                self.emit(QtCore.SIGNAL("changed()"))
            self.actualizaBotones()


    def fechaChanged(self, date):           # print "ventas.igu.Administrador.fechaChanged()", date
        if self.ui.fecha1.date() > self.ui.fecha2.date():
            self.ui.fecha1.setDate(self.ui.fecha2.date())
        self.actualizaConsulta()


    def modifica(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Modificar venta", u"Seleccione la Venta que quiere MODIFICAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(QtCore.Qt.UserRole).toInt()[0]
            self.owner.captura.modifica(id)


    def mostrarDetalles(self, item):
        # id = self.ui.tablaConsulta.item(item.row(), 0).data(1000).toInt()[0]
        self.owner.detalles.actualiza()
        self.owner.detalles.show()
        self.owner.ui.innerSplitter.setSizes([1, 1])

    def mostrarMenuConsulta(self, pos):
        pos = self.ui.tablaConsulta.mapToGlobal(pos)
        self.menuTablaConsulta.popup(pos)


    def nombreClienteEditado(self, texto):  # print "ventas.igu.Administrador.nombreClienteEditado()"
        filtros = {}
        filtros['nombre'] = unicode(texto)

        clientes = manejador.rolesI(**filtros)

        ids = [x.id for x in clientes]
        nombres = ["%s %s" % (x.entidad.nombre, x.entidad.nombre2) for x in clientes]

        self.sender().completer().data = ids
        self.sender().completer().model().setStringList(nombres)

        self.cliente = None


    def nombreClienteSeleccionado(self, completerModelIndex):
        m = "ventas.igu.Captura.nombreclienteSeleccionado()"
        # print (1), m

        cliente = manejador.rolesI(id=self.sender().data[completerModelIndex.row()])
        self.clienteSeleccionado(cliente)


    def resizedTablaConsulta(self, event):  # print "ventas.igu.Administrador.resizedTablaConsulta()"
        headerWidth = self.ui.tablaConsulta.width()-self.ui.tablaConsulta.verticalHeader().width()-self.ui.tablaConsulta.verticalScrollBar().width()
        self.ui.tablaConsulta.horizontalHeader().setMinimumWidth(headerWidth)

        porcentajes = [10, 10, 15, 12, 12]
        overflow = 0

        for index in range(self.ui.tablaConsulta.horizontalHeader().count()-1):

            self.ui.tablaConsulta.resizeColumnToContents(index)

            porContenido = self.ui.tablaConsulta.columnWidth(index)
            calculado = headerWidth * porcentajes[index] / 100

            if porContenido < calculado:
                if overflow:
                    offset = calculado - porContenido
                    if offset > overflow:
                        calculado = calculado - overflow
                        overflow = 0
                    else:
                        overflow -= offset
                        calculado = porContenido
                self.ui.tablaConsulta.setColumnWidth(index, calculado)
            else:
                overflow += porContenido - calculado

    def selectionChanged(self):             # print "ventas.igu.Administrador.selectionChanged()"
        if not self.ui.chSumasDiarias.isChecked():
            if self.ui.tablaConsulta.currentRow() != -1:
                # id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
                self.owner.detalles.actualiza()
                # if self.owner.detalles.isVisible():
                    # self.owner.detalles.mostrar(id)
                if self.owner.captura.isVisible():
                    if self.owner.captura.modo == 'modificar':
                        if self.owner.captura.id != id:
                            if self.owner.captura.estaModificado():
                                result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Modificación de Compra", u"La captura de Venta tiene cambios\n\n¿Quieres Guardar los cambios para %s %s %s?" % (self.owner.captura.old.tipo, self.owner.captura.old.folio, self.owner.captura.old.fecha), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)

                                if result == QtGui.QMessageBox.Yes:
                                    self.owner.captura.guarda()
                            self.owner.captura.modifica(id)
            self.actualizaBotones()


    def showed(self):
        controller.app.forma.informacion = u""


    def sumasDiariasChanged(self, state):
        self.actualizaConsulta()



class Captura(cdFrame.CDFrame):

    def __init__(self, *args, **kwds):
        m = "ventas.igu.Captura.__init__()"
        # print (1), m

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        self.__modo = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = captura_ui.Ui_Form()
        self.ui.setupUi(self)

        self.connect(self.ui.frame, QtCore.SIGNAL('returnPressed()'), self.returnPressed)

        ## Folio
        font = QtGui.QFont()
        font.setBold(True)
        font.setPointSize(10)
        self.ui.edFolio.setFont(font)
        self.ui.edFolio.setAlignment(QtCore.Qt.AlignHCenter)
        self.ui.edFolio.setStyleSheet("color:#2020FF;")
        # if self.owner.app.reach&3:
            # self.ui.edFolio.setReadOnly(False)

        ## Fecha
        self.ui.fecha.setDisplayFormat('dd MMM yyyy')
        self.ui.fecha.setMaximumDate(QtCore.QDate(QtCore.QDate().currentDate().year(), 12, QtCore.QDate().currentDate().day()))
        self.ui.fecha.hide()

        ## Orden de compra
        self.ui.frOrden.setVisible(False)

        ## Código de producto
        completer = QtGui.QCompleter([], self.ui.edCodigoProducto)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        model = Model(completer)
        completer.setModel(model)
        self.ui.edCodigoProducto.setCompleter(completer)
        # self.ui.edCodigoProducto.setInputMask(">")
        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.codigoProductoSeleccionado)
        self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('returnPressed()'), self.codigoProductoCapturado)
        self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('textEdited(QString)'), self.codigoProductoEditado)

        ## Código de producto 2
        completer = QtGui.QCompleter([], self.ui.edCodigoProducto2)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.ui.edCodigoProducto2.setCompleter(completer)
        # self.ui.edCodigoProducto.setInputMask(">")
        # self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.codigoProductoSeleccionado)
        # self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('returnPressed()'), self.codigoProductoCapturado)
        self.connect(self.ui.edCodigoProducto2, QtCore.SIGNAL('textEdited(QString)'), self.codigoProducto2Editado)

        self.ui.frCodigo2.hide()

        ## Nombre de producto
        completer = QtGui.QCompleter([], self.ui.edNombreProducto)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)

        model = Model(completer)
        completer.setModel(model)

        self.ui.edNombreProducto.setCompleter(completer)

        # completer.setCompletionMode(QtGui.QCompleter.PopupCompletion)

        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.nombreProductoSeleccionado)
        self.connect(self.ui.edNombreProducto, QtCore.SIGNAL('returnPressed()'), self.nombreProductoCapturado)
        self.connect(self.ui.edNombreProducto, QtCore.SIGNAL("textEdited(QString)"), self.nombreProductoEditado)

        # Linea de producto
        # self.ui.cbClasificacion.hide()
        # completer = QtGui.QCompleter([], self.ui.cbLinea)
        # completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        # completer.setCompletionMode(QtGui.QCompleter.PopupCompletion)
        # self.ui.edClasificacion.setCompleter(completer)
        # self.connect(self.ui.edClasificacion, QtCore.SIGNAL('returnPressed()'), self.clasificacionCapturada)
        # self.connect(self.ui.edClasificacion, QtCore.SIGNAL("textEdited(QString)"), self.clasificacionEditada)
        # self.cargaClasificaciones()

        ## Nuevo producto
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Plus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.newProductBU.setIcon(icon)
        self.connect(self.ui.newProductBU, QtCore.SIGNAL('clicked()'), self.addProduct)

        ## Cliente
        self.ui.selectorCliente = selectorCliente.Forma(self, u'clientes')
        self.ui.selectorCliente.setContent(self.ui.selectorCliente.content() ^ self.ui.selectorCliente.TELEFONO)
        self.ui.layoutEncabezado.insertWidget(1, self.ui.selectorCliente)
        self.connect(self.ui.selectorCliente, QtCore.SIGNAL("clienteEdited()"), self.clienteEditado)
        self.connect(self.ui.selectorCliente, QtCore.SIGNAL("clienteSelected()"), self.clienteSeleccionado)
        self.connect(self.ui.selectorCliente, QtCore.SIGNAL("clientesChanged()"), self.clientesChanged)
        self.connect(self.ui.selectorCliente, QtCore.SIGNAL('lugaresChanged()'), self.lugaresChanged)

        ## Tabla Partidas
        self.ui.tablaPartidas = TablaPartidas(self.ui.frame, owner=self, controlador=self.owner)
        self.ui.tablaPartidas.setFrameShape(QtGui.QFrame.NoFrame)
        self.ui.tablaPartidas.setFrameShadow(QtGui.QFrame.Raised)
        self.ui.tablaPartidas.setStyleSheet('background-color:#F8F8FF;')
        self.ui.tablaPartidas.setTabKeyNavigation(False)

        labels = [u"Código", u"Nombre", u"Línea", u"Cantidad", u"Precio", u"Importe"]
        self.ui.tablaPartidas.setColumnCount(len(labels))
        self.ui.tablaPartidas.setHorizontalHeaderLabels(labels)
        self.ui.tablaPartidas.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)

        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(self.ui.tablaPartidas.sizePolicy().hasHeightForWidth())

        self.ui.tablaPartidas.setSizePolicy(sizePolicy)

        self.ui.layoutCaptura.insertWidget(3, self.ui.tablaPartidas)

        self.connect(self.ui.tablaPartidas, QtCore.SIGNAL("totalChanged(dec)"), self.totalChanged)
        self.connect(self.ui.tablaPartidas, QtCore.SIGNAL('editingFinished()'), self.partidaCapturada)
        self.connect(self.ui.tablaPartidas, QtCore.SIGNAL('toggleRequested(QWidget)'), self.toggleRequested)

        ## Tipo de documento  (Debe aparecer despues de Cliente y Tabla Partidas)
        # self.ui.cbTipoDocumento.setAlignment(QtCore.Qt.AlignHCenter)
        self.ui.cbTipoDocumento.clear()
        tipos = manejador.tiposDocumento()
        for tipo in tipos:
            self.ui.cbTipoDocumento.addItem(tipo.nombre.capitalize(), QtCore.QVariant(tipo.id))
        self.ui.cbTipoDocumento.setCurrentIndex(-1)
        self.connect(self.ui.cbTipoDocumento, QtCore.SIGNAL("currentIndexChanged(QString)"), self.tipoDocumentoCambiado)
        self.ui.cbTipoDocumento.setCurrentIndex(self.ui.cbTipoDocumento.findData(manejador.tipoDocumentoDefault()))

        ## Preset Impuestos para Cálculo de total
        self.impuestoGeneralFactor = (manejador.impuestoGeneral() + dec('100')) / dec('100')

        ## Rangos Precio
        # self.connect(self.ui.boRangoPrecio, QtCore.SIGNAL('clicked()'), self.toggleRangoPrecio)
        self.toggleRangoPrecio(0)

        ## Subtotal
        self.ui.edSubtotal.setMinimumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edSubtotal.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edSubtotal.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edSubtotal.setRange(0, 99999)

        ## Descuento
        self.ui.edDescuento.setMinimumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edDescuento.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edDescuento.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edDescuento.setRange(0, 99999)
        self.connect(self.ui.edDescuento, QtCore.SIGNAL('editingFinished()'), self.totalChanged)

        ## Impuesto
        self.ui.edImpuesto.setMinimumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edImpuesto.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edImpuesto.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edImpuesto.setRange(0, 99999)

        ## Total
        font.setPointSize(9)
        self.ui.edTotal.setFont(font)
        self.ui.edTotal.setMinimumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edTotal.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edTotal.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edTotal.setRange(0, 99999)
        self.connect(self.ui.edTotal, QtCore.SIGNAL('editingFinished()'), self.totalChanged)

        ## Pago
        # self.ui.laPago.hide()
        # self.ui.edPago.hide()
        # self.ui.laCambio.hide()
        # self.ui.edCambio.hide()
        # self.ui.laCondiciones.hide()
        # self.ui.cbCondiciones.hide()

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cash.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boPagar.setIcon(icon)

        self.connect(self.ui.boPagar, QtCore.SIGNAL('clicked()'), self.paga)

        self.pago = Pago(self)

        # self.ui.edPago.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        # self.ui.edPago.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        # self.ui.edPago.setStyleSheet('background-color:#F8F8FF')
        # self.ui.edPago.setRange(0, 99999)
        # self.ui.edPago.setPrefijoMensaje("el pago")
        # self.loadCapturaPagoObligatoria()
        # self.connect(self.ui.edPago, QtCore.SIGNAL("textEdited(QString)"), self.actualizaCambio)

        ## Cambio
        # self.ui.edCambio.setFont(font)
        # self.ui.edCambio.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        # self.ui.edCambio.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        # self.ui.edCambio.setReadOnly(True)

        ## Condiciones de Pago
        # self.ui.cbCondiciones.setFont(font)
        # self.ui.cbCondiciones.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        # self.connect(completer, QtCore.SIGNAL("activated(int)"), self.nombreProductoSeleccionado)
        # self.connect(self.ui.cbCondiciones, QtCore.SIGNAL('currentIndexChanged(int)'), self.condicionesChanged)
        # self.connect(self.ui.cbCondiciones, QtCore.SIGNAL('editTextChanged(QString)'), self.condicionesEdited)
        # self.connect(self.ui.cbCondiciones, QtCore.SIGNAL('lostFocus()'), self.condicionesLostFocus)
        # self.cargaCondiciones()

        ## Guardar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Check.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boGuardar.setIcon(icon)
        self.ui.boGuardar.setIconSize(QtCore.QSize(32,32))
        self.ui.boGuardar.setEnabled(False)
        self.ui.boGuardar.setDefault(True)
        self.connect(self.ui.boGuardar, QtCore.SIGNAL('clicked()'), self.guarda)

        ## Limpiar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Restart.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boLimpiar.setIcon(icon)
        self.ui.boLimpiar.setIconSize(QtCore.QSize(32,32))
        self.connect(self.ui.boLimpiar, QtCore.SIGNAL('clicked()'), self.limpia)

        ## Cancelar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cancel.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boCancelar.setIcon(icon)
        self.ui.boCancelar.setIconSize(QtCore.QSize(32,32))
        self.connect(self.ui.boCancelar, QtCore.SIGNAL('clicked()'), self.cancela)

        self.connect(controller.eventRouter, QtCore.SIGNAL('lineasChangedBroadcast()'), self.cargaLineas)
        self.connect(controller.eventRouter, QtCore.SIGNAL('clientesChangedBroadcast()'), self.ui.selectorCliente.cargaNombres)
        self.connect(controller.eventRouter, QtCore.SIGNAL('lugaresChangedBroadcast()'), self.ui.selectorCliente.cargaLugares)
        self.connect(controller.eventRouter, QtCore.SIGNAL('capturaPagoObligatoriaChanged'), self.loadCapturaPagoObligatoria)
        self.connect(controller.eventRouter, QtCore.SIGNAL('rangosPrecioChangedBroadcast()'), self.rangosPrecioChanged)

        self.connect(self, QtCore.SIGNAL('showed()'), self.showed)

        ## posSet
        self.setTabOrder(self.ui.cbTipoDocumento, self.ui.edFolio)
        self.setTabOrder(self.ui.edFolio, self.ui.fecha)
        self.setTabOrder(self.ui.fecha, self.ui.edOrden)
        self.setTabOrder(self.ui.edOrden, self.ui.selectorCliente.ui.edNombre)
        self.setTabOrder(self.ui.selectorCliente.ui.edNombre, self.ui.selectorCliente.ui.edNombre2)
        self.setTabOrder(self.ui.selectorCliente.ui.edNombre2, self.ui.selectorCliente.ui.edCalle)
        self.setTabOrder(self.ui.selectorCliente.ui.edCalle, self.ui.selectorCliente.ui.edAreaNominal)
        self.setTabOrder(self.ui.selectorCliente.ui.edAreaNominal, self.ui.selectorCliente.ui.cbLugar)
        self.setTabOrder(self.ui.selectorCliente.ui.cbLugar, self.ui.selectorCliente.ui.edRFC)
        self.setTabOrder(self.ui.selectorCliente.ui.edRFC, self.ui.selectorCliente.ui.edTelefono)
        self.setTabOrder(self.ui.selectorCliente.ui.edTelefono, self.ui.edCodigoProducto)
        self.setTabOrder(self.ui.edCodigoProducto, self.ui.edCodigoProducto2)
        self.setTabOrder(self.ui.edCodigoProducto2, self.ui.edNombreProducto)
        self.setTabOrder(self.ui.edNombreProducto, self.ui.cbLinea)
        self.setTabOrder(self.ui.cbLinea, self.ui.tablaPartidas)
        self.setTabOrder(self.ui.tablaPartidas, self.ui.boCancelar)
        self.setTabOrder(self.ui.boCancelar, self.ui.boLimpiar)
        self.setTabOrder(self.ui.boLimpiar, self.ui.boGuardar)
        self.setTabOrder(self.ui.boGuardar, self.ui.edSubtotal)
        # self.setTabOrder(self.ui.edPago, self.ui.edCambio)
        # self.setTabOrder(self.ui.edCambio, self.ui.boGuardar)
        # self.setTabOrder(self.ui.edPago, self.ui.edSubtotal)
        self.setTabOrder(self.ui.edSubtotal, self.ui.edDescuento)
        self.setTabOrder(self.ui.edDescuento, self.ui.edImpuesto)
        self.setTabOrder(self.ui.edImpuesto, self.ui.edTotal)
        # self.setTabOrder(self.ui.edTotal, self.ui.boGuardar)

        self.loadCapturaPagoObligatoria()

        # self.agrega()


    def addProduct(self):               # print "ventas.igu.Captura.addProduct()"
        controller.eventRouter.emit(QtCore.SIGNAL('addProduct(bool)'), True)


    def acepcionSeleccionada(self, acepcion):
        m = "ventas.igu.Captura.acepcionSeleccionada(%s)" % acepcion
        # print (1), m

        if self.ui.edCodigoProducto.text() or self.ui.edNombreProducto.text():
            precioLista = [x for x in acepcion.producto.atributos if x.nombre==u'precio' and x.atributo_id==self.rangosPrecioActivos[self.rangoPrecioActual].id]

            if precioLista:
                precio = dec(precioLista[0].valor)
            else:
                precio = dec("0.00")

            row = self.ui.tablaPartidas.rowCount()

            self.ui.tablaPartidas.setDatosRenglon(row, acepcion, dec('0.0'), precio)

            self.ui.edCodigoProducto.setText("")
            self.ui.edCodigoProducto2.setText("")
            self.ui.edNombreProducto.setText("")
            self.ui.cbLinea.setText("")
            # self.ui.cbClasificacion.setCurrentIndex(0)

            self.ui.tablaPartidas.setCurrentCell(row, CANTIDAD)
            self.ui.tablaPartidas.editItem(self.ui.tablaPartidas.item(row, CANTIDAD))
            self.actualizaStatus()

            self.ui.frameNombre.setEnabled(True)
            self.ui.frameNombre.setToolTip("")
            self.ui.frameClasificacion.setEnabled(True)


    def actualizaStatus(self):          # print "ventas.igu.Captura.actualizaStatus()"
        if self.modo == "modificar":
            if self.estaModificado():
                if self.esValida():
                    self.ui.boGuardar.setEnabled(True)
                    self.ui.boGuardar.setToolTip(u"")
                else:
                    self.ui.boGuardar.setEnabled(False)
                    self.ui.boGuardar.setToolTip(u"No hay cambios")
            else:
                self.ui.boGuardar.setEnabled(False)
                self.ui.boGuardar.setToolTip(u"No hay cambios")

        elif self.modo == 'agregar':
            if self.esValida():
                self.ui.boGuardar.setEnabled(True)
            else:
                self.ui.boGuardar.setEnabled(False)
            self.ui.boGuardar.setToolTip(self.mensajes)

        if self.ui.edTotal.value():
            self.ui.boPagar.setEnabled(True)
        else:
            self.ui.boPagar.setEnabled(False)


    def agrega(self):
        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "VENTA", None, QtGui.QApplication.UnicodeUTF8))
        self.__modo = 'agregar'
        self.clear()

        self.ui.edFolio.setText(manejador.dameFolio(unicode(self.ui.cbTipoDocumento.currentText())))

        self.ui.fecha.setDate(QtCore.QDate().currentDate())
        self.ui.laFecha.setText(QtCore.QDate().currentDate().toString('dd MMM yyyy'))
        self.ui.edCodigoProducto.setEnabled(True)
        self.ui.edCodigoProducto2.setEnabled(True)
        self.ui.edNombreProducto.setEnabled(True)
        self.ui.cbLinea.setEnabled(True)
        # self.ui.edClasificacion.setEnabled(True)
        # self.ui.cbClasificacion.setEnabled(True)

        self.pago.clear()

        self.actualizaStatus()
        # self.owner.owner.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre\n\nPara activar la barra principal, presione F10"

        self.owner.setInnerStatus('hidden')

        self.ui.edNombreProducto.setFocus()

        self.show()


    def cancela(self):
        self.clear()
        self.hide()
        self.emit(QtCore.SIGNAL("capturaClosed()"))


    def cargaCondiciones(self):         # print "ventas.igu.Captura.cargaCondiciones()"
        registros = manejador.condicionesPago()
        self.ui.cbCondiciones.clear()
        for registro in registros:
            self.ui.cbCondiciones.addItem(registro.nombre, QtCore.QVariant(registro.id))


    def condicionesChanged(self):
        self.actualizaStatus()


    def condicionesEdited(self):
        if self.ui.cbCondiciones.findText(self.ui.cbCondiciones.currentText(), QtCore.Qt.MatchStartsWith) == -1:
            self.ui.cbCondiciones.setStyleSheet("background-color:#FFFF60;")
        else:
            self.ui.cbCondiciones.setStyleSheet("background-color:#FFFFFF;")
        self.actualizaStatus()


    def condicionesLostFocus(self):     # print "ventas.igu.Captura.condicionesLostFocus()"
        if self.ui.cbCondiciones.findText(self.ui.cbCondiciones.currentText(), QtCore.Qt.MatchStartsWith) == -1:
            self.ui.cbCondiciones.setStyleSheet("background-color:#FFFF60;")
        else:
            self.ui.cbCondiciones.setStyleSheet("background-color:#FFFFFF;")
            self.ui.cbCondiciones.setCurrentIndex(self.ui.cbCondiciones.findText(self.ui.cbCondiciones.currentText(), QtCore.Qt.MatchStartsWith))
        self.actualizaStatus()


    def cargaLineas(self):
        self.ui.cbLinea.clear()

        lineas = manejador.lineas()
        for linea in lineas:
            self.ui.cbLinea.addItem(linea.nombre, QtCore.QVariant(linea.id))

        # ids = [x.id for x in lineas]
        # nombres = ["%s" % x.nombre for x in lineas]
        # self.ui.edClasificacion.completer().data = ids
        # self.ui.edClasificacion.completer().model().setStringList(nombres)


    def clasificacionEditada(self, texto):
        pass
        # self.sender().setText(self.sender().text().toUpper())
        # filtros = {}
        # filtros['clasificacion'] = unicode(texto.toUpper())
        # filtros['rol_id'] = -1

        # acepciones = manejador.dameAcepciones(**filtros)

        # ids = [x.id for x in acepciones]
        # codigos = ["%s" % x.codigo for x in acepciones]

        # self.sender().completer().data = ids
        # self.sender().completer().model().setStringList(codigos)


    def clasificacionCapturada(self):   # print "ventas.igu.Captura.clasificacionCapturada()"
        model = self.ui.edClasificacion.completer().completionModel()
        self.ui.edClasificacion.setText(self.ui.edClasificacion.completer().completionModel().data(self.ui.edClasificacion.completer().currentIndex()).toString())

        # clasificacion = manejador.dameClasificacion(id=self.sender().data[completerModelIndex.row()])
        # self.acepcionSeleccionada(acepcion)


    def clear(self):
        m = "ventas.igu.Captura.clear()"
        # print (1), m

        self.ui.edCodigoProducto.clear()
        self.ui.edCodigoProducto2.clear()
        self.ui.edNombreProducto.clear()
        # self.ui.cbClasificacion.setCurrentIndex(-1)
        self.ui.cbLinea.clear()

        cliente = manejador.rolI(id=int(manejador.atributoI(grupo=u'cliente', nombre=u'default').valor))

        self.ui.selectorCliente.setData(cliente)

        self.ui.tablaPartidas.setRowCount(0)

        self.totalChanged(dec('0.00'))
        # self.ui.edSubtotal.setValue(dec('0.00'))
        # self.ui.edDescuento.setValue(dec('0.00'))
        # self.ui.edImpuesto.setValue(dec('0.00'))
        # self.ui.edTotal.setValue(dec('0.00'))

        self.ui.boPagar.setEnabled(False)
        # self.ui.edPago.clear()
        # self.ui.edCambio.clear()
        # self.ui.cbCondiciones.setCurrentIndex(-1)
        self.ui.laTotalConLetras.setText("")


    def clienteEditado(self):
        self.actualizaStatus()


    def clienteSeleccionado(self):      # print "ventas.igu.Captura.clienteSeleccionado()"
        #! Checar manejo de rango Precio
        self.actualizaStatus()
        self.ui.edNombreProducto.setFocus()


    def clientesChanged(self):          # print "ventas.igu.Captura.clientesChanged()"
        self.emit(QtCore.SIGNAL("clientesChanged()"))


    def close(self):                    # print "ventas.igu.Captura.close()"
        self.pago.destroy()


    def codigoProductoCapturado(self):
        m = "ventas.igu.Captura.codigoProductoCapturado()"
        print (1), m

        if self.ui.edCodigoProducto.completer().completionCount() == 1:
            if self.ui.edCodigoProducto.completer().popup().currentIndex().row() == -1:
                model = self.ui.edCodigoProducto.completer().completionModel()
                index = model.index(0, 0)
                self.codigoProductoSeleccionado(index)

            # self.ui.edCodigoProducto.setText(self.ui.edCodigoProducto.completer().currentCompletion())
        # acepcion = manejador.dameAcepcion(codigo=unicode(self.ui.edCodigoProducto.text()), rol_id=controller.app.holder.id)
        # self.acepcionSeleccionada(acepcion)


    def codigoProductoEditado(self, texto):
        if len(texto) < 2:
            self.ui.edCodigoProducto.completer().model().clear()

        elif len(texto) == 2:
            filtros = {}
            filtros['codigo'] = unicode(texto.toUpper())
            filtros['rol_id'] = controller.app.holder.id
            # self.sender().setText(self.sender().text().toUpper())
            # if self.ui.edClasificacion.text():
                # filtros['clasificacion'] = unicode(self.ui.edClasificacion.text())
            acepciones = manejador.dameAcepciones(**filtros)

            self.ui.edCodigoProducto.completer().model().clear()

            if not acepciones:
                self.ui.frameCodigo.setToolTip(u"El proveedor no tiene productos que lleven estas iniciales en el código")
            else:
                self.ui.frameCodigo.setToolTip(u"")

                ## Set Model Data
                for row, acepcion in enumerate(acepciones):
                    self.ui.edCodigoProducto.completer().model().setData(row, "%s %s" % (acepcion.codigo, acepcion.nombre))
                    self.ui.edCodigoProducto.completer().model().setData(row, acepcion.id, 1001)

                self.ui.edCodigoProducto.completer().model().reset()

                # ids = [x.id for x in acepciones]
                # codigos = ["%s" % x.codigo for x in acepciones]

                # self.sender().completer().data = ids
                # self.sender().completer().model().setStringList(codigos)

        if self.ui.edCodigoProducto.text():
            self.ui.frameNombre.setEnabled(False)
            self.ui.frameNombre.setToolTip(u"Desactivado si se busca por codigo")
            self.ui.frLinea.setEnabled(False)
            self.ui.frLinea.setToolTip(u"Desactivado si se busca por codigo")
        else:
            self.ui.frameNombre.setEnabled(True)
            self.ui.frameNombre.setToolTip("")
            self.ui.frLinea.setEnabled(True)
            self.ui.frLinea.setToolTip(u"")


            # ids = [x.id for x in acepciones]
            # codigos = ["%s" % x.codigo for x in acepciones]

            # self.sender().completer().data = ids
            # self.sender().completer().model().setStringList(codigos)


    def codigoProductoSeleccionado(self, completerModelIndex): # print "ventas.igu.Captura.codigoProductoSeleccionado()"

        completerRow = completerModelIndex.row()

        model = self.ui.edCodigoProducto.completer().completionModel()

        # acepcionOrigen = manejador.acepcionI(id=model.data(model.index(completerRow, 0), 1001).toInt()[0])

        # Si no existe la acepción para el rol seleccionado, se utiliza la acepción para el origen seleccionado.
        # if manejador.acepcionExists(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]):
            # acepcionRol = manejador.acepcionI(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0])
        # else:
            # acepcionRol = acepcionOrigen
        acepcion = manejador.acepcionI(id=model.data(model.index(completerRow, 0), 1001).toInt()[0])

        # ! checar el costo

        self.ui.tablaPartidas.setDatosRenglon(rowIndex=None, acepcion=acepcion, cantidad=dec('0.0'), precio=acepcion.costo)

        self.ui.edCodigoProducto.setText("")
        self.ui.edNombreProducto.setText("")
        self.ui.cbLinea.setCurrentIndex(-1)

        self.ui.frameNombre.setEnabled(True)
        self.ui.frameNombre.setToolTip("")
        self.ui.frLinea.setEnabled(True)

        self.ui.tablaPartidas.setCurrentCell(self.ui.tablaPartidas.rowCount()-1, CANTIDAD)
        self.ui.tablaPartidas.editItem(self.ui.tablaPartidas.item(self.ui.tablaPartidas.rowCount()-1, CANTIDAD))

        self.actualizaStatus()

        # acepcion = manejador.dameAcepcion(id=self.sender().data[completerModelIndex.row()])
        # self.acepcionSeleccionada(acepcion)


    def codigoProducto2Editado(self, texto):
        self.sender().setText(self.sender().text().toUpper())
        filtros = {}
        filtros['codigo'] = unicode(texto.toUpper())
        filtros['rol_id'] = controller.app.holder.id
        if self.ui.edClasificacion.text():
            filtros['clasificacion'] = unicode(self.ui.edClasificacion.text())

        acepciones = manejador.dameAcepciones(**filtros)

        ids = [x.id for x in acepciones]
        codigos = ["%s" % x.codigo for x in acepciones]

        self.sender().completer().data = ids
        self.sender().completer().model().setStringList(codigos)


    def datos(self):
        m = "ventas.igu.Captura.datos()"

        datos = {}

        if self.modo == 'modificar':
            datos['id'] = self.id

        datos['tipoDocumento_id'] = self.ui.cbTipoDocumento.itemData(self.ui.cbTipoDocumento.currentIndex()).toInt()[0]
        datos['folioDocumento'] = unicode(self.ui.edFolio.text())
        datos['fecha'] = self.ui.fecha.dateTime().toPyDateTime()

        if self.ui.selectorCliente.rol:
            datos['rol_id'] = self.ui.selectorCliente.rol.id
        else:
            datos['rol_id'] = None
            datos['cliente'] = self.ui.selectorCliente.data()
            datos['tipo'] = u'cliente'

        # try:
            # datos['rol_id'] = self.ui.selectorCliente.cliente.id
        # except:
            # datos['rol_id'] = None

        datos['subtotal'] = self.ui.edSubtotal.value()
        datos['descuento'] = self.ui.edDescuento.value()
        datos['impuesto'] = self.ui.edImpuesto.value()
        datos['total'] = self.ui.edTotal.value()

        # datos['pago'] = self.ui.edPago.value()
        datos['pago'] = self.pago.datos

        datos['partidas'] = self.ui.tablaPartidas.data()

        return datos


    def estaModificado(self):
        if self.modo == 'modificar':
            data = self.datos()
            try:
                if self.old.rol_id==data['rol_id'] and self.old.subtotal==data['subtotal'] and self.old.descuento==data['descuento'] and self.old.impuesto==data['impuesto'] and self.old.total==data['total'] and not self.ui.tablaPartidas.estaModificado():
                    return False
                else:
                    return True
            except:
                return True
        else:
            return True


    def esValida(self):                 # print "ventas.igu.Captura.esValida()"
        valida = True
        self.mensajes = ""

        if not self.ui.fecha.lineEdit().text():
            valida = False
            self.mensajes += u"Falta la fecha\n"

        if not self.ui.selectorCliente.esValido():
            valida = False
            self.mensajes += self.ui.selectorCliente.mensajes
        else:
            if self.ui.selectorCliente.rol:
                if unicode(self.ui.cbTipoDocumento.currentText())==u'factura':
                    if self.ui.selectorCliente.rol.entidad.nombre == u'Público':
                        valida = False
                        self.mensajes += u"Debe capturar un cliente válido\n"

        partidasValidas, mensajes = self.ui.tablaPartidas.esValida()
        if not partidasValidas:
            valida = False
            self.mensajes += mensajes

        if not self.ui.edSubtotal.isValid:
            valida = False
            self.mensajes += u"Subtotal fuera de rango\n"

        if not self.ui.edDescuento.isValid:
            valida = False
            self.mensajes += u"Descuento fuera de rango\n"

        if not self.ui.edImpuesto.isValid:
            valida = False
            self.mensajes += u"Impuesto fuera de rango\n"

        if not self.ui.edTotal.isValid:
            valida = False
            self.mensajes += u"Total fuera de rango\n"

        if self.capturaPagoObligatoria:

            if not self.pago.capturado:
                valida = False
                self.mensajes += u"Falta capturar el pago"

        self.mensajes = self.mensajes.rstrip("\n")

        return valida


    def guarda(self):                   # print "ventas.igu.Captura.guarda()"
        ## No se revisa validez de datos, para llegar aquí se tuvo que haber hecho
        ## Se solicita autorización para datos (cliente nuevo)
        self.setCursor(QtCore.Qt.WaitCursor)

        datos = self.datos()

        rolTemp = datos['rol_id']

        if self.modo == "agregar":
            documento = manejador.agrega(datos)
            if manejador.atributoI(grupo=u'venta', nombre=u'seImprimeComprobante').valor:
                self.owner.imprime(documento)
            self.agrega()

        elif self.modo == "modificar":
            manejador.modifica(datos)

        controller.eventRouter.emit(QtCore.SIGNAL("ventasChangedBroadcast()"))
        controller.eventRouter.emit(QtCore.SIGNAL("productosChangedBroadcast()"))

        if not rolTemp:
            controller.eventRouter.emit(QtCore.SIGNAL("clientesChangedBroadcast()"))

        self.setCursor(QtCore.Qt.ArrowCursor)

    @property
    def impuestoIncluido(self):
        return self.__impuestoIncluido


    def limpia(self):
        self.clear()


    def loadCapturaPagoObligatoria(self): # print "ventas.igu.Captura.loadCapturaPagoObligatoria()"
        self.capturaPagoObligatoria = manejador.atributoI(grupo=u'venta', nombre=u'capturaPagoObligatoria').valor
        # if self.capturaPagoObligatoria:
            # self.ui.edPago.setEmptyAllowed(False)
        # else:
            # self.ui.edPago.setEmptyAllowed(True)
        self.actualizaStatus()


    def lugaresChanged(self):
        self.emit(QtCore.SIGNAL("lugaresChanged()"))


    def modifica(self, id):
        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "Modificación de Venta", None, QtGui.QApplication.UnicodeUTF8))
        self.clear()
        self.__modo = "modificar"

        self.id = id
        data = manejador.documento(id=id)
        self.setData(data)

        self.ui.edCodigoProducto.setEnabled(False)
        self.ui.edCodigoProducto2.setEnabled(False)
        self.ui.edNombreProducto.setEnabled(False)
        self.ui.cbLinea.setEnabled(False)
        # self.ui.cbClasificacion.setEnabled(False)

        self.ui.tablaPartidas.setModo(self.modo)

        self.actualizaStatus()
        # self.owner.owner.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre"

        self.owner.setInnerStatus('hidden')

        self.ui.selectorCliente.ui.edNombre.setFocus()

        self.show()


    @property
    def modo(self):
        return self.__modo


    def nombreProductoCapturado(self):
        m = "ventas.igu.Captura.nombreProductoCapturado()"
        # print (1), m

        if self.ui.edNombreProducto.completer().completionCount() == 1:
            if self.ui.edNombreProducto.completer().popup().currentIndex().row() == -1:
                model = self.ui.edNombreProducto.completer().completionModel()
                index = model.index(0, 0)
                self.nombreProductoSeleccionado(index)

            # self.ui.edNombreProducto.setText(self.ui.edNombreProducto.completer().currentCompletion())


    def nombreProductoEditado(self, texto):
        m = "ventas.igu.Captura.nombreProductoEditado()"
        # print (1), m

        if len(texto) < 2:
            self.ui.edNombreProducto.completer().model().clear()
        # acepciones = []
        # self.sender().completer().data = []
        # self.sender().completer().model().setStringList([])

        elif len(texto) == 2:
            filtros = {}
            # if self.ui.edCodigoProducto.text():
                # filtros['codigo'] = unicode(self.ui.edCodigoProducto.text().toUpper())
            filtros['nombre'] = unicode(texto)
            filtros['rol_id'] = controller.app.holder.id

            # if self.ui.edClasificacion.text():
                # filtros['linea'] = unicode(self.ui.edClasificacion.text())


            acepciones = manejador.dameAcepciones(**filtros)
            self.ui.edNombreProducto.completer().model().clear()

            ## Set Model Data
            for row, acepcion in enumerate(acepciones):
                self.ui.edNombreProducto.completer().model().setData(row, "%s %s %s" % (acepcion.nombre, acepcion.producto.lineas[0].nombre, acepcion.codigo))
                self.ui.edNombreProducto.completer().model().setData(row, acepcion.id, 1001)

            self.ui.edNombreProducto.completer().model().reset()

            # linea = manejador.atributoI(id=x.producto.lineas[0].valor)

            # ids = [x.id for x in acepciones]
            # nombres = ["%s - %s - %s" % (x.nombre, x.codigo, x.producto.lineas[0].nombre) for x in acepciones]

            # self.sender().completer().data = ids
            # self.sender().completer().model().setStringList(nombres)


    def nombreProductoSeleccionado(self, completerModelIndex=None):
        m = "ventas.igu.Captura.nombreProductoSeleccionado()"
        # print (1), m

        completerRow = completerModelIndex.row()

        model = self.ui.edNombreProducto.completer().completionModel()

        # acepcionOrigen = manejador.acepcionI(id=model.data(model.index(completerRow, 0), 1001).toInt()[0])

        # Si no existe la acepción para el rol seleccionado, se utiliza la acepción para el origen seleccionado.
        # if manejador.acepcionExists(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]):
            # acepcionRol = manejador.acepcionI(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0])
        # else:
            # acepcionRol = acepcionOrigen
        acepcion = manejador.acepcionI(id=model.data(model.index(completerRow, 0), 1001).toInt()[0])

        # ! checar el costo

        self.ui.tablaPartidas.setDatosRenglon(rowIndex=None, acepcion=acepcion, cantidad=dec('0.0'), precio=acepcion.costo)

        self.ui.edCodigoProducto.setText("")
        self.ui.edNombreProducto.setText("")
        self.ui.cbLinea.setCurrentIndex(-1)

        self.ui.tablaPartidas.setCurrentCell(self.ui.tablaPartidas.rowCount()-1, CANTIDAD)
        self.ui.tablaPartidas.editItem(self.ui.tablaPartidas.item(self.ui.tablaPartidas.rowCount()-1, CANTIDAD))

        self.actualizaStatus()


    @property
    def owner(self):
        return self.__owner


    def paga(self):                     # print "ventas.igu.Captura.paga()"
        self.pago.setImporte(self.ui.edTotal.value())
        result = self.pago.exec_()
        if result == QtGui.QDialog.Accepted:
            self.actualizaStatus()
        else:
            print "hju"


    def partidaCapturada(self):
        self.ui.edNombreProducto.setFocus()


    def partidasClicked(self, index):   # print "ventas.igu.Captura.partidasClicked()"
        self.ui.tablaPartidas.edit(index)


    @property
    def rangoPrecioActual(self):
        ## Index
        return self.__rangoPrecioActual


    @property
    def rangosPrecioActivos(self):
        return self.owner.rangosPrecioActivos


    def rangosPrecioChanged(self):
        pass
        #! Do whatever needs to be done


    def returnPressed(self):            # print "ventas.igu.Captura.returnPressed()"
        if self.ui.boGuardar.isEnabled():
            self.guarda()


    def rfcEditado(self, text):
        filtros = {}
        if text:
            filtros['rfc'] = "LIKE %s%%" % text
        clientes = self.owner.bd.getMany("clientes", filtros)
        ids = [x['cliente_id'] for x in clientes]
        rfcs = [x['rfc'] for x in clientes]
        self.ui.edRFC.completer().data = ids
        self.ui.edRFC.completer().model().setStringList(rfcs)


    def setData(self, data):
        m = "ventas.igu.Captura.setData()"
        # print (1), m, data

        direccion = data.rol.direcciones[0]

        #! Tipo de documento

        self.ui.edFolio.setText(data.folio)
        self.ui.fecha.setDate(QtCore.QDate().fromString(data.fecha.strftime("%d%m%Y"), "ddMMyyyy"))

        self.ui.selectorCliente.setData(data.rol)

        self.ui.edSubtotal.setValue(data.subtotal)
        self.ui.edDescuento.setValue(data.descuento)
        self.ui.edImpuesto.setValue(data.impuesto)
        self.ui.edTotal.setValue(data.total)

        pagoZero = [x for x in data.operacion.procesos[0].operaciones if x.tipo==u'cobro']

        if pagoZero:
            self.pago.setData(pagoZero[0])

        # operacion = manejador.dameOperacion(documento_id=data.id)

        # self.pago.setDatos(operacion.referencia)

        # if operacion.referencia:
            # self.ui.edPago.setText("%s" % operacion.referencia)
        # else:
            # self.ui.edPago.setText("")

        self.ui.tablaPartidas.setData(data.partidas)


    def setImpuestoIncluido(self, value):
        m = "ventas.igu.Captura.setImpuestoIncluido()"
        # print (1), m

        if value:
            self.__impuestoIncluido = True
        else:
            self.__impuestoIncluido = False

        self.totalChanged(self.ui.tablaPartidas.getSubtotal())


    def showed(self):
        controller.app.forma.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre\n\nPara activar la barra principal, presione F10"
        # self.owner.owner.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre\n\nPara activar la barra principal, presione F10"


    def tipoDocumentoCambiado(self, text=None):
        m = "ventas.igu.Captura.tipoDocumentoCambiado()"
        # print (1), m

        text = unicode(text).lower()

        if text == u'factura':
            self.ui.selectorCliente.setRfcObligatorio(True)
            self.setImpuestoIncluido(False)

        elif text == u'remisión':
            self.ui.selectorCliente.setRfcObligatorio(False)
            self.setImpuestoIncluido(True)

        self.ui.tablaPartidas.redraw()

        self.ui.edFolio.setText(manejador.dameFolio(text))
        self.actualizaStatus()


    def toggleRangoPrecio(self, rango=None):
        m = "ventas.igu.Captura.toggleRangoPrecio()"
        # print (1), m

        if rango is None:   # rango es el index
            if self.rangoPrecioActual+1 == len(self.rangosPrecioActivos):
                self.__rangoPrecioActual = 0
            else:
                self.__rangoPrecioActual += 1
        else:
            self.__rangoPrecioActual = rango

        self.ui.boRangoPrecio.setText(self.rangosPrecioActivos[self.rangoPrecioActual].valor)
        # self.ui.tablaPartidas.cambiaPrecios(self.rangoPrecioActual)
        self.ui.tablaPartidas.redraw()


    def toggleRequested(self, arg):     # print "ventas.igu.Captura.toggleRequested()"
        # print self.ui.tablaPartidas.currentItem().setData(QtCore.Qt.EditRole,
        # print self.ui.tablaPartidas.indexFromItem(arg)
        self.ui.tablaPartidas.currentItem().setData(QtCore.Qt.EditRole, QtCore.QVariant("%.2f" % dec("%.0f" % dec(str(item.data(QtCore.Qt.UserRole+1).toString())))))



    def totalChanged(self, subtotal=None):
        m = "ventas.igu.Captura.totalChanged()"
        # print (1), m

        if subtotal is None:
            subtotal = self.ui.edSubtotal.value()

        descuento = self.ui.edDescuento.value()

        total = subtotal - descuento
        if self.impuestoIncluido:
            impuesto = dec("0.00")
        else:
            impuesto = subtotal * manejador.impuestoGeneral() / dec('100')

        total += impuesto

        self.ui.edSubtotal.setValue(subtotal)
        self.ui.edDescuento.setValue(descuento)
        self.ui.edImpuesto.setValue(impuesto)
        self.ui.edTotal.setValue(total)

        if total:
            self.ui.laTotalConLetras.setText("Son %s" % utilities.moneyToText(self.ui.edTotal.value().quantize(dec('0.01'))))
            self.ui.boPagar.setEnabled(True)
        else:
            self.ui.boPagar.setEnabled(False)

        self.actualizaStatus()
        # self.actualizaCambio()


class Detalles(QtGui.QFrame):

    @property
    def eventRouter(self):
        return self.__owner.eventRouter

    @property
    def owner(self):
        return self.__owner

    def __init__(self, *args, **kwds):
        m = "ventas.igu.Detalles.__init__()"

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = detalles_ui.Ui_Form()
        self.ui.setupUi(self)

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.toImprimir.setIcon(icon)

        self.connect(self.ui.toImprimir, QtCore.SIGNAL("clicked()"), self.imprimir)

        self.connect(self, QtCore.SIGNAL("doubleClicked()"), self.close)

        self.connect(controller.eventRouter, QtCore.SIGNAL("clientesChangedBroadcast()"), self.actualiza)
        self.connect(controller.eventRouter, QtCore.SIGNAL("ventasChangedBroadcast()"), self.actualiza)

        self.partidas = []
        self.status = 'normal'


    def actualiza(self):                    # print "ventas.igu.Detalles.actualiza()"
        if self.owner.administrador.ui.tablaConsulta.selectedItems():
            id = self.owner.administrador.ui.tablaConsulta.item(self.owner.administrador.ui.tablaConsulta.currentRow(), 0).data(QtCore.Qt.UserRole).toInt()[0]

            proceso = manejador.dameProceso(id=id)

            self.setData(proceso)


    def imprimir(self):
        proceso = self.data
        documento = ([x for x in proceso.operaciones if x.tipo==u'salida'][0]).documentos[0]
        self.owner.imprime(documento)


    def setData(self, proceso):                # print "ventas.igu.Detalles.setData()"

        self.data = proceso

        data = ([x for x in proceso.operaciones if x.tipo==u'salida'][0]).documentos[0]

        self.ui.laEtiquetaFolio.setText(data.tipo.nombre.capitalize())
        self.ui.laFolio.setText(" %s" % data.folio)
        self.ui.laFecha.setText(data.fecha.strftime("%d %b %Y"))
        self.ui.laEntidad.setText("%s %s" % (data.rol.entidad.nombre, data.rol.entidad.nombre2))
        self.ui.laSubtotal.setText("%.2f" % data.subtotal)
        self.ui.laDescuento.setText("%.2f" % data.descuento)
        self.ui.laImpuesto.setText("%.2f" % data.impuesto)
        self.ui.laTotal.setText("%.2f" % data.total)

        font = QtGui.QFont()
        font.setBold(True)
        font.setPointSize(9)

        font2 = QtGui.QFont()
        font2.setBold(True)
        font2.setPointSize(8)

        for row, partida in enumerate(data.partidas):
            if row+1 == self.ui.layoutPartidas.rowCount():
                renglon = [QtGui.QLabel(""), QtGui.QLabel(""), QtGui.QLabel(""), QtGui.QLabel(""), QtGui.QLabel(""), QtGui.QLabel("")]
                self.partidas.append(renglon)
                for column in range(6):
                    self.ui.layoutPartidas.addWidget(self.partidas[row][column], row+1, column)
                    if column in [0, 2]:
                        self.partidas[row][column].setFont(font2)
                    else:
                        self.partidas[row][column].setFont(font)
                self.partidas[row][3].setAlignment(QtCore.Qt.AlignCenter)
                self.partidas[row][4].setAlignment(QtCore.Qt.AlignRight)
                self.partidas[row][5].setAlignment(QtCore.Qt.AlignRight)

            for column in range(6):
                self.partidas[row][column].show()

            acepcion = manejador.dameAcepcion(producto_id=partida.producto_id, rol_id=controller.app.holder.id)

            self.partidas[row][0].setText("%s" % acepcion.codigo)
            self.partidas[row][1].setText(" %s" % acepcion.nombre)
            self.partidas[row][2].setText(" %s" % acepcion.producto.lineas[0].nombre)
            self.partidas[row][3].setText("%s" % partida.cantidad)
            if partida.precioneto:
                self.partidas[row][4].setText("%.2f" % partida.precioneto)
            self.partidas[row][5].setText("%.2f" % (partida.cantidad * partida.precioneto))

        for row in range(len(data.partidas), len(self.partidas)):
            for column in range(6):
                self.partidas[row][column].hide()



class Pago(QtGui.QDialog):

    @property
    def capturado(self):
        return self.__capturado

    @property
    def recibido(self):
        return self.ui.edMontoRecibido.value()

    @property
    def tipo(self):
        return self.__tipo

    def __init__(self, *args, **kwds):
        m = "ventas.igu.Pago.__init__()"
        # print (1), m

        QtGui.QDialog.__init__(self, *args)

        self.ui = pagos_ui.Ui_Dialog()
        self.ui.setupUi(self)

        self.setWindowTitle(QtGui.QApplication.translate("DsDialog", "Taller Básico", None, QtGui.QApplication.UnicodeUTF8))
        self.setWindowIcon(QtGui.QIcon("imagenes/logo.png"))

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boToggle.setIcon(icon)
        self.connect(self.ui.boToggle, QtCore.SIGNAL('clicked()'), self.triggered)

        self.tipos = [x.nombre for x in manejador.formasPagoI()]

        ## Importe
        self.ui.edImporte.setEnabled(False)

        ## Efectivo - recibido
        # self.ui.edMontoRecibido.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edMontoRecibido.setStyleSheet('background-color:#F8F8FF;')
        self.ui.edMontoRecibido.setRange(0, 99999)
        self.ui.edMontoRecibido.setPrefijoMensaje("el pago")
        self.connect(self.ui.edMontoRecibido, QtCore.SIGNAL("textEdited(QString)"), self.actualizaCambio)

        ## Efectivo - cambio
        self.ui.edCambio.setEnabled(False)

        ## Credito - plazo
        self.cargaCondiciones()
        self.connect(self.ui.cbPlazo, QtCore.SIGNAL('activated(int)'), self.plazoSeleccionado)

        ## Credito - pago inicial
        self.ui.frPagoInicial.hide()

        ## Aceptar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Checkmark.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boAceptar.setIcon(icon)
        self.connect(self.ui.boAceptar, QtCore.SIGNAL('clicked()'), self.aceptar)

        ## Cancelar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cancel.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boCancelar.setIcon(icon)
        self.connect(self.ui.boCancelar, QtCore.SIGNAL('clicked()'), self.cancelar)

        self.connect(self.ui.boToggle, QtCore.SIGNAL('clicked()'), self.triggered)

        self.__tipo = 0
        self.triggered(0)
        self.__capturado = False


    def aceptar(self):
        self.__capturado = True
        self.accept()


    def actualizaCambio(self):      # print "ventas.igu.Pago.actualizaCambio()"
        cambio = self.ui.edMontoRecibido.value() - self.ui.edImporte.value()
        self.ui.edCambio.setValue(cambio)
        self.actualizaStatus()


    def actualizaStatus(self):
        if self.esValido():
            self.ui.boAceptar.setEnabled(True)
            self.ui.boAceptar.setToolTip(u'OK')
        else:
            self.ui.boAceptar.setEnabled(False)
            self.ui.boAceptar.setToolTip(self.mensajes)


    def cancelar(self):
        self.reject()


    def cargaCondiciones(self):     # print "ventas.igu.Pago.cargaCondiciones()"
        registros = manejador.condicionesPago()
        self.ui.cbPlazo.clear()
        for registro in registros:
            self.ui.cbPlazo.addItem(registro.valor, QtCore.QVariant(registro.id))


    def clear(self):
        self.__capturado = False
        self.__tipo = 0

        self.ui.edImporte.setText(u'')
        self.ui.edMontoRecibido.setText(u'')
        self.ui.edCambio.setText(u'')

        self.ui.cbPlazo.setCurrentIndex(-1)


    @property
    def datos(self):
        datos = {}
        datos['total'] = self.ui.edImporte.value()
        if self.tipos[self.tipo] == u'efectivo':
            datos['tipo'] = u'efectivo'
            datos['montoRecibido'] = self.ui.edMontoRecibido.value()
            datos['cambio'] = self.ui.edCambio.value()
        elif self.tipos['self.tipo'] == u'cheque':
            datos['tipo'] = u'cheque'
            datos['fecha'] = self.ui.daFecha.dateTime.toPyDate()
            datos['numero'] = self.ui.edNumero.text()
            datos['banco_id'] = self.ui.cbBanco.itemData(self.ui.cbBanco.currentIndex())
            # datos['emisor_id'] = self.
            datos['monto'] = self.ui.edMonto.value()

        return datos


    def esValido(self):             # print "ventas.igu.Pago.esValido()"
        valido = True
        self.mensajes = u''
        if self.tipos[self.tipo] == u'Efectivo':
            if self.ui.edCambio.value() < dec('0'):
                valido = False
                self.mensajes += u"El monto recibido no es válido\n"
        elif self.tipos[self.tipo] == u'Crédito':
            if not self.ui.cbPlazo.currentText():
                valido = False
                self.mensajes += u"Falta el plazo\n"

        elif self.tipos[self.tipo] == u'Banco':
            if not self.ui.cbBanco.currentText():
                valido = False
                self.mensajes += u"Falta el Banco\n"
        self.mensajes = self.mensajes.rstrip('\n')
        return valido


    def setData(self, datos): # Recibe Operacion
        # print "ventas.igu.Pago.setDatos()"

        documento = datos.documentos[0]

        self.ui.edImporte.setValue(documento.total)

        if documento.tipo.nombre == u'efectivo':
            self.ui.edMontoRecibido.setValue(dec(documento.subtotal))
            self.ui.edCambio.setValue(dec(documento.descuento))
        elif documento.tipo.nombre == u'cheque':
            self.ui.cbBanco.setCurrentIndex(self.ui.cbBanco.findData(int(documento.referencia)))
            self.ui.edNumero.setText(documento.folio)
            self.ui.daFecha.setDate(documento.fecha)
            self.ui.edMonto.setValue(documento.subtotal)
            self.ui.edEmisor.setText(u'%s %s' % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2))


    def setImporte(self, valor):
        self.ui.edImporte.setValue(valor)
        self.actualizaCambio()
        self.ui.edMontoRecibido.setFocus()


    def plazoSeleccionado(self):
        self.actualizaStatus()


    def triggered(self, index=None): # print "ventas.igu.Pago.triggered()"
        if index is None:
            if self.tipo+1 == len(self.tipos):
                self.__tipo = 0
            else:
                self.__tipo += 1
        else:
            self.__tipo = index

        if self.tipos[self.tipo] == u'cheque':
            self.ui.frEfectivo1.hide()
            self.ui.frCheque1.show()
            self.ui.frCredito1.hide()

            self.ui.frEfectivo.hide()
            self.ui.frBanco.show()
            self.ui.frCredito.hide()

        elif self.tipos[self.tipo] == u'crédito':
            self.ui.frEfectivo1.hide()
            self.ui.frCheque1.hide()
            self.ui.frCredito1.show()

            self.ui.frEfectivo.hide()
            self.ui.frBanco.hide()
            self.ui.frCredito.show()

        elif self.tipos[self.tipo] == u'efectivo':
            self.ui.frEfectivo1.show()
            self.ui.frCheque1.hide()
            self.ui.frCredito1.hide()

            self.ui.frEfectivo.show()
            self.ui.frBanco.hide()
            self.ui.frCredito.hide()
        self.actualizaStatus()



class TablaPartidas(QtGui.QTableWidget):
    """ #!
        This thing must have it's own datasource, because it must know what the
        actual different prices and taxes are available, appart from the actual
        data captured in the cells. setData won't expect this background data,
        it expects the actual data displayed in the cells.
        MUST REFACTOR THIS TO MAKE THE TABLE CONTAIN ALL THE DATA NECESARY
    """

    def __init__(self, *args, **kwds):
        m = "ventas.igu.TablaPartidas.__init__()"
        # print (1), m

        if kwds.has_key('modo'):
            self.__modo = kwds.pop('modo')
        else:
            self.__modo = None

        if kwds.has_key('controlador'):
            self.__controlador = kwds.pop('controlador')
        else:
            self.__controlador = None

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QTableWidget.__init__(self, *args)

        self.setWordWrap(False)
        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)

        self.aEliminar = QtGui.QAction("Elimina", self)

        self.menu = QtGui.QMenu(self)
        self.menu.addAction(self.aEliminar)

        self.connect(self, QtCore.SIGNAL("itemChanged(QTableWidgetItem *)"), self.itemChanged)
        self.connect(self, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.muestraMenu)

        self.connect(self.aEliminar, QtCore.SIGNAL("triggered()"), self.elimina)

        self.setStatus(u'normal')

        self.rol = controller.app.holder

        delegate = Delegate(self)

        self.setItemDelegate(delegate)


    def data(self):                     # print "ventas.igu.TablaPartidas.data()"
        partidas = []
        for row in range(self.rowCount()):
            partida = {}
            partida['producto_id'] = self.item(row, 0).data(1000).toInt()[0]

            producto = manejador.productoI(id=partida['producto_id'])

            try:
                partida['cantidad'] = dec(str(self.item(row, 3).text()))
            except:
                partida['cantidad'] = dec("0.00")

            try:
                partida['costo'] = producto.costopromedio
            except:
                partida['costo'] = dec("0.00")

            partida['impuesto'] = manejador.impuestoGeneral()

            if self.owner.impuestoIncluido:
                try:
                    partida['precioneto'] = dec(str(self.item(row, 4).text()))
                    partida['precio'] = partida['precioneto'] / self.owner.impuestoGeneralFactor
                except:
                    partida['precioneto'] = dec("0.00")
                    partida['precio'] = dec("0.00")
            else:
                try:
                    partida['precio'] = dec(str(self.item(row, 4).text()))
                    partida['precioneto'] = partida['precio'] * self.owner.impuestoGeneralFactor
                except:
                    partida['precio'] = dec("0.00")
                    partida['precioneto'] = dec("0.00")

            partida['descuento'] = dec("0.00")
            # partida['status'] = u"ejecutada"
            partidas.append(partida)

        return partidas


    def elimina(self):
        remove = True
        # if self.currentRow() < 0:
            # result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar partida", u"Selecciona la PARTIDA que quieres ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
            # remove = False
        # else:
            # result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar partida", u"¿Realmente quieres ELIMINAR la PARTIDA?", QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
            # if result == QtGui.QMessageBox.No:
                # remove = False

        if remove:
            self.removeRow(self.currentRow())
            self.emit(QtCore.SIGNAL("totalChanged(dec)"), self.getSubtotal())


    def estaModificado(self):           # print "ventas.igu.TablaPartidas.estaModificado()"
        if self.modo == 'modificar':
            modificado = False
            data = self.data()
            for index, item in enumerate(self.partidasOld):
                if not(item.cantidad==data[index]['cantidad'] and item.costo==data[index]['costo']):
                    modificado = True
            return modificado


    def esValida(self):                 # print "ventas.igu.TablaPartidas.esValida()"
        valida = True
        self.mensajes = ""

        if self.rowCount():
            partidas = self.data()
            for index, partida in enumerate(partidas):
                if self.item(index, 3).data(QtCore.Qt.UserRole+1).toString() == 'overflow':
                    valida = False
                    self.mensajes += u"La partida %s sobrepasa las existencias\n" % (index + 1)
                elif partida['cantidad'] == dec("0.0"):
                    valida = False
                    self.mensajes += u"partida %s sin cantidad\n" % (index + 1)
        else:
            valida = False
            self.mensajes += u"No hay partidas capturadas\n"

        return valida, self.mensajes


    def event(self, event):             # print "ventas.igu.TablaPartidas.event()"
        if event.type() == QtCore.QEvent.KeyPress:
            if event.key() == QtCore.Qt.Key_Return:
                if self.currentColumn() == 3:
                    self.setCurrentCell(self.currentRow(), 4)
                elif self.currentColumn() == 4:
                    self.emit(QtCore.SIGNAL('editingFinished()'))
        return QtGui.QTableWidget.event(self, event)


    def getSubtotal(self):              # print "ventas.igu.TablaPartidas.getSubtotal()"
        subtotal = dec("0.00")
        for row in range(self.rowCount()):
            importe = dec(str(self.item(row, 5).text()))        # Importe
            subtotal += importe
        return subtotal


    @property
    def modo(self):
        return self.__modo


    def itemChanged(self, item):        # print "ventas.igu.TablaPartidas.itemChanged()", item.row(), item.column(), item.text().toUtf8()
        if self.status == 'normal':
            if item.column() in [3, 4]:
                self.redraw(item)


    def muestraMenu(self, pos):
        pos = self.mapToGlobal(pos)
        self.menu.popup(pos)


    @property
    def owner(self):
        return self.__owner


    def redraw(self, item=None):
        m = "ventas.igu.TablaPartidas.redraw()"
        # print (1), m

        def redrawRow(item):

            ## Validar existencias
            if self.item(item.row(), CODIGO).data(1001).toString() != u'Servicio':
                if dec(str(self.item(item.row(), CANTIDAD).data(1000).toString())) < dec(str(self.item(item.row(), CANTIDAD).text())):
                    self.item(item.row(), CANTIDAD).setData(1001, QtCore.QVariant("overflow"))
                    for colIndex in range(self.columnCount()):
                        self.item(item.row(), colIndex).setBackgroundColor(QtGui.QColor("#FF8080"))
                else:
                    self.item(item.row(), CANTIDAD).setData(1001, QtCore.QVariant(""))
                    for colIndex in range(self.columnCount()):
                        self.item(item.row(), colIndex).setBackgroundColor(QtGui.QColor("#FFFFFF"))

            ## Recalcular
            if self.owner.impuestoIncluido:
                self.item(item.row(), PRECIO).setText("%s" % dec(str(self.item(item.row(), PRECIO).data(1000+self.owner.rangoPrecioActual*10).toString())).quantize(dec('0.01')))

            else:
                self.item(item.row(), PRECIO).setText("%s" % dec(str(self.item(item.row(), PRECIO).data(1001+self.owner.rangoPrecioActual*10).toString())).quantize(dec('0.01')))

            importe = (dec(str(self.item(item.row(), CANTIDAD).text())) * dec(str(self.item(item.row(), PRECIO).text()))).quantize(dec('0.01'))

            self.item(item.row(), IMPORTE).setText("%s" % importe)

        if item is None:
            for rowIndex in range(self.rowCount()):
                redrawRow(self.item(rowIndex, 0))
        else:
            redrawRow(item)

        self.emit(QtCore.SIGNAL("totalChanged(dec)"), self.getSubtotal())


    def setData(self, partidas):
        # print "ventas.igu.TablaPartidas.setData()"

        for index, partida in enumerate(partidas):
            acepcion = manejador.acepcionI(producto_id=partida.producto_id, rol_id=controller.app.holder.id)

            self.setDatosRenglon(index, acepcion, partida.cantidad, partida.precio)



    def setDatosRenglon(self, rowIndex, acepcion, cantidad, precio):
        m = "ventas.igu.TablaPartidas.setDatosRenglon()"


        if rowIndex is None:
            rowIndex = self.rowCount()
            self.insertRow(self.rowCount())
        else:
            if self.rowCount() <= rowIndex:
                self.insertRow(self.rowCount())

        informacion = u""
        oldStatus = self.status
        self.setStatus(u'settingDatosRenglon')

        ## Código - data=producto_id
        item = QtGui.QTableWidgetItem("%s" % acepcion.codigo)   # may be int not unicode
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        item.setData(1000, QtCore.QVariant(acepcion.producto_id))
        item.setData(1001, QtCore.QVariant(acepcion.producto.tipo.nombre))
        self.setItem(rowIndex, CODIGO, item)




        ## Nombre
        item = QtGui.QTableWidgetItem(acepcion.nombre)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(rowIndex, NOMBRE, item)

        ## LINEA
        item = QtGui.QTableWidgetItem(acepcion.producto.lineas[0].nombre)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(rowIndex, LINEA, item)

        ## CANTIDAD
        item = QtGui.QTableWidgetItem("%s" % cantidad)
        item.setTextAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
        item.setData(1000, QtCore.QVariant("%s" % acepcion.producto.actual))
        self.setItem(rowIndex, CANTIDAD, item)

        ## PRECIO
        """ 1000 Precio Iva incluido
            1001 Precio Iva desglosado """
        item = QtGui.QTableWidgetItem("-1")
        item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)

        if self.owner.impuestoIncluido:
            item.setText("%s" % precio)
        else:
            item.setText("%s" % precio)

        for rango in self.owner.rangosPrecioActivos:
            precioX = [x for x in acepcion.producto.precios if x.atributo_id==rango.id]
            if precioX:
                precioX = precioX[0]
                index = int(rango.referencia[0]) - 1
                item.setData(1000+index*10, QtCore.QVariant("%s" % dec(precioX.valor)))
                item.setData(1001+index*10, QtCore.QVariant("%s" % (dec(precioX.valor)/ self.owner.impuestoGeneralFactor)))

        self.setItem(rowIndex, PRECIO, item)

        ## IMPORTE
        importe = cantidad * precio

        item = QtGui.QTableWidgetItem("%.2f" % importe)
        item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(rowIndex, IMPORTE, item)


        self.redraw(self.item(rowIndex, 0))

        self.setStatus(u'normal')

        self.resizeColumnToContents(CODIGO)
        self.resizeColumnToContents(LINEA)
        self.resizeColumnToContents(CANTIDAD)

        informacion += u"Presiona F2 para modificar datos en la celda\n"

        controller.app.forma.informacion = informacion.rstrip(u'\n')


    def setModo(self, modo):            # print "ventas.igu.TablaPartidas.setModo()"
        self.__modo = modo

        if modo == 'agregar':
            self.menu = QtGui.QMenu(self)
            self.menu.addAction(self.aElimina)
        elif modo == 'modificar':
            self.menu = QtGui.QMenu(self)


    def setStatus(self, valor):
        self.__status = valor


    @property
    def status(self):
        return self.__status



class Delegate(QtGui.QItemDelegate):

    def createEditor(self, parent, option, index):
        if index.column() == CANTIDAD:
            editor = cdNumberEdit.CDNumberEdit(parent)
            editor.hasStatusLabel(False)
            self.connect(editor, QtCore.SIGNAL('returnPressed()'), self.commitAndCloseEditor)
            return editor
        elif index.column() == PRECIO:
            editor = PartidaNumberEdit(parent)
            editor.hasStatusLabel(False)
            self.connect(editor, QtCore.SIGNAL('returnPressed()'), self.commitAndCloseEditor)
            return editor
        else:
            return QtGui.QItemDelegate.createEditor(self, parent, option, index)

    def commitAndCloseEditor(self):
        editor = self.sender()
        if isinstance(editor, (QtGui.QTextEdit, QtGui.QLineEdit)):
            self.emit(QtCore.SIGNAL('commitData(QWidget*)'), editor)
            self.emit(QtCore.SIGNAL('closeEditor(QWidget*)'), editor)
            self.emit(QtCore.SIGNAL('editingFinished(QWidget*)'), editor)



class Splitter(QtGui.QSplitter):

    def __init__(self, *args):
        self.orientation = args[0]
        QtGui.QSplitter.__init__(self, *args)

    def createHandle(self):
        return Handle(self.orientation, self)



class Handle(QtGui.QSplitterHandle):

    def __init__(self, *args):
        QtGui.QSplitterHandle.__init__(self, *args)

    def mouseDoubleClickEvent(self, event): # print "Handle.mousePressEvent()"
        self.emit(QtCore.SIGNAL("handlePressed"))


class PartidaNumberEdit(cdNumberEdit.CDNumberEdit):

    def __init__(self, *args, **kwds):  # print "cdNumberEdit.CDNumberEdit.__init__()", args, kwds
        cdNumberEdit.CDNumberEdit.__init__(self, *args)

    def keyPressEvent(self, event):     # print "PartidaNumberEdit.keyPressEvent()"
        # print event.key()
        cdNumberEdit.CDNumberEdit.keyPressEvent(self, event)
        if event.key() == 80:   # P
            self.parent().parent().emit(QtCore.SIGNAL('toggleRequested(QWidget)'), self)


class Model(QtCore.QAbstractListModel):

    def __init__(self, *args):
        QtCore.QAbstractListModel.__init__(self, *args)
        self.__data = []


    def clear(self):
        # self.beginRemoveRows(QtCore.QModelIndex(), 0, self.rowCount())
        self.__data = []
        self.reset()
        # self.endRemoveRows()


    def data(self, index, role=QtCore.Qt.DisplayRole):
        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            return self.__data[index.row()][index.column()]
        elif role == QtCore.Qt.TextAlignmentRole:
            # if index.column() == CANTIDAD:
                # return QtCore.QVariant(int(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter))
            # if index.column() in [PRECIO, IMPORTE]:
                # return QtCore.QVariant(int(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter))
            return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
        elif role == 1001:
            return self.__data[index.row()][1]
        else:
            return QtCore.QVariant()


    def insertRow(self, row, parent=QtCore.QModelIndex()):
        self.__data.insert(row, [QtCore.QVariant(u""), QtCore.QVariant(u"")])
        return True


    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.__data)


    def setData(self, row, valor, role=QtCore.Qt.DisplayRole):
        """ No se usa la porquería de modelIndex """
        if row >= len(self.__data):
            self.__data.append([None, None])

        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            self.__data[row][0] = QtCore.QVariant(valor)
        elif role == 1001:
            self.__data[row][1] = QtCore.QVariant(valor)
        else:
            print "puaj"
        return True




# print (0), "  ventas.igu            end"



"""
Comportamiento para edPago y edCambio (incluye cambios a capturaPagoObligatoria)

Comportamiento para cbTipoDocumento
    No se debe facturar a Público general
    No se puede facturar a cliente nulo
    No se puede remisionar a cliente nulo

    Toggle impuestoIncluido
    Carga el folio correspondiente

21NOV09
Los precios son afectados por 2 factores hasta el momento :
    El impuesto
        Por el momento es sólo el IVA, y aplica por igual a todos los productos y
            servicios.
    El rango de precio
        Por el momento se contemplan 2, el General y el Preferente, el segundo se
            inicia deshabilitado

    Esto genera que la celda de precio de tabla de partidas maneje hasta 4 valores
        diferentes:
        Precio General con Impuesto
        Precio General sin Impuesto
        Precio Preferente con Impuesto
        Precio Preferente sin Impuesto

    Technicallity
        Las variantes de valores por cada celda se guardan en la variable data del
        item de esa celda.
        La variable data maneja roles y da opcion a varios definidos por el programador.
        Se manejaran los siguientes roles:
            QtCore.Qt.UserRole+1    Precio General con Impuesto
            QtCore.Qt.UserRole+2    Precio General sin Impuesto
            QtCore.Qt.UserRole+11   Precio Preferente con Impuesto
            QtCore.Qt.UserRole+12   Precio Preferente sin Impuesto
            Futuros nuevos rangos de Precio usarían lo siguiente
            QtCore.Qt.UserRole+21   Precio 3 con Impuesto
            QtCore.Qt.UserRole+22   Precio 3 sin Impuesto
            QtCore.Qt.UserRole+31   Precio 4 con Impuesto
            QtCore.Qt.UserRole+32   Precio 4 sin Impuesto

    Se puede hacer un cambio de Rangos de Precio, en los siguientes casos
    1- Cuando se cambia de cliente se puede recibir un evento de cambioRangoPrecio cuyo argumento
        es el rango seleccionado
    2- Cuando el usuario quiere consultar un valor de un rango diferente al actual


"""

"""
Situaciones

Se selecciona un cliente que no tiene registrado RFC
    - Si el tipo de documento es Remisión no hay error.
    - Si el tipo de documento es Factura es error y se tiene que capturar el RFC y registrsrlo.


"""
